@sparkdreamnft/sparkdreamjs 0.0.27 → 0.0.29

package/akash/take/v1/paramsmsg.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgUpdateParamsResponse = exports.MsgUpdateParams = void 0;
+//@ts-nocheck
+const params_1 = require("./params");
+const binary_1 = require("../../../binary");
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: params_1.Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ *
+ * Since: akash v1.0.0
+ * @name MsgUpdateParams
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.MsgUpdateParams
+ */
+exports.MsgUpdateParams = {
+    typeUrl: "/akash.take.v1.MsgUpdateParams",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(18).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 = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = params_1.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_1.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_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgUpdateParams.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.take.v1.MsgUpdateParams",
+            value: exports.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.take.v1
+ * @see proto type: akash.take.v1.MsgUpdateParamsResponse
+ */
+exports.MsgUpdateParamsResponse = {
+    typeUrl: "/akash.take.v1.MsgUpdateParamsResponse",
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = 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 exports.MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.take.v1.MsgUpdateParamsResponse",
+            value: exports.MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};

package/akash/take/v1/query.d.ts

@@ -0,0 +1,95 @@
+import { Params, ParamsAmino } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsRequest
+ */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/akash.take.v1.QueryParamsRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequestAmino
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsRequest
+ */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "/akash.take.v1.QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsResponse
+ */
+export interface QueryParamsResponse {
+    /**
+     * params defines the parameters of the module.
+     */
+    params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/akash.take.v1.QueryParamsResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponseAmino
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsResponse
+ */
+export interface QueryParamsResponseAmino {
+    /**
+     * params defines the parameters of the module.
+     */
+    params: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "/akash.take.v1.QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsRequest
+ */
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+};
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsResponse
+ */
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+};

package/akash/take/v1/query.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryParamsResponse = exports.QueryParamsRequest = void 0;
+//@ts-nocheck
+const params_1 = require("./params");
+const binary_1 = require("../../../binary");
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsRequest
+ */
+exports.QueryParamsRequest = {
+    typeUrl: "/akash.take.v1.QueryParamsRequest",
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = 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 exports.QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.take.v1.QueryParamsRequest",
+            value: exports.QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: params_1.Params.fromPartial({})
+    };
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package akash.take.v1
+ * @see proto type: akash.take.v1.QueryParamsResponse
+ */
+exports.QueryParamsResponse = {
+    typeUrl: "/akash.take.v1.QueryParamsResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(10).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 = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = params_1.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_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : params_1.Params.toAmino(params_1.Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.take.v1.QueryParamsResponse",
+            value: exports.QueryParamsResponse.encode(message).finish()
+        };
+    }
+};

package/akash/take/v1/query.lcd.d.ts

@@ -0,0 +1,9 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Params returns the total set of minting parameters. */
+    params = async (_params = {}) => {
+        const endpoint = `akash/take/v1/params`;
+        return await this.req.get(endpoint);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/akash/take/v1/query.rpc.Query.d.ts

@@ -0,0 +1,16 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse } from "./query";
+/** Query defines the gRPC querier service of the take package. */
+export interface Query {
+    /** Params returns the total set of minting parameters. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+};

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Params returns the total set of minting parameters. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.take.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/akash/take/v1/service.amino.d.ts

@@ -0,0 +1,8 @@
+import { MsgUpdateParams } from "./paramsmsg";
+export declare const AminoConverter: {
+    "/akash.take.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./paramsmsg").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./paramsmsg").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+};

package/akash/take/v1/service.amino.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const paramsmsg_1 = require("./paramsmsg");
+exports.AminoConverter = {
+    "/akash.take.v1.MsgUpdateParams": {
+        aminoType: "/akash.take.v1.MsgUpdateParams",
+        toAmino: paramsmsg_1.MsgUpdateParams.toAmino,
+        fromAmino: paramsmsg_1.MsgUpdateParams.fromAmino
+    }
+};

package/akash/take/v1/service.d.ts

@@ -0,0 +1 @@
+export {};

package/akash/take/v1/service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/akash/take/v1/service.registry.d.ts

@@ -0,0 +1,25 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { Registry } from "@cosmjs/proto-signing";
+import { MsgUpdateParams } from "./paramsmsg";
+export declare const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]>;
+export declare const load: (protoRegistry: Registry) => void;
+export declare const MessageComposer: {
+    encoded: {
+        updateParams(value: MsgUpdateParams): {
+            typeUrl: string;
+            value: Uint8Array<ArrayBufferLike>;
+        };
+    };
+    withTypeUrl: {
+        updateParams(value: MsgUpdateParams): {
+            typeUrl: string;
+            value: MsgUpdateParams;
+        };
+    };
+    fromPartial: {
+        updateParams(value: MsgUpdateParams): {
+            typeUrl: string;
+            value: MsgUpdateParams;
+        };
+    };
+};

package/akash/take/v1/service.registry.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageComposer = exports.load = exports.registry = void 0;
+const paramsmsg_1 = require("./paramsmsg");
+exports.registry = [["/akash.take.v1.MsgUpdateParams", paramsmsg_1.MsgUpdateParams]];
+const load = (protoRegistry) => {
+    exports.registry.forEach(([typeUrl, mod]) => {
+        protoRegistry.register(typeUrl, mod);
+    });
+};
+exports.load = load;
+exports.MessageComposer = {
+    encoded: {
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.take.v1.MsgUpdateParams",
+                value: paramsmsg_1.MsgUpdateParams.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.take.v1.MsgUpdateParams",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.take.v1.MsgUpdateParams",
+                value: paramsmsg_1.MsgUpdateParams.fromPartial(value)
+            };
+        }
+    }
+};

package/akash/take/v1/service.rpc.msg.d.ts

@@ -0,0 +1,18 @@
+import { TxRpc } from "../../../types";
+import { MsgUpdateParams, MsgUpdateParamsResponse } from "./paramsmsg";
+/** Msg defines the market Msg service */
+export interface Msg {
+    /**
+     * UpdateParams defines a governance operation for updating the x/market module
+     * parameters. The authority is hard-coded to the x/gov module account.
+     *
+     * Since: akash v1.0.0
+     */
+    updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    updateParams: (request: MsgUpdateParams) => Promise<MsgUpdateParamsResponse>;
+}
+export declare const createClientImpl: (rpc: TxRpc) => MsgClientImpl;

package/akash/take/v1/service.rpc.msg.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientImpl = exports.MsgClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const paramsmsg_1 = require("./paramsmsg");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* UpdateParams defines a governance operation for updating the x/market module
+     parameters. The authority is hard-coded to the x/gov module account.
+    
+     Since: akash v1.0.0 */
+    updateParams = async (request) => {
+        const data = paramsmsg_1.MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("akash.take.v1.Msg", "UpdateParams", data);
+        return promise.then(data => paramsmsg_1.MsgUpdateParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/akash/take/v1beta3/genesis.d.ts

@@ -0,0 +1,47 @@
+import { Params, ParamsAmino } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * GenesisState stores slice of genesis deployment instance
+ * @name GenesisState
+ * @package akash.take.v1beta3
+ * @see proto type: akash.take.v1beta3.GenesisState
+ */
+export interface GenesisState {
+    params: Params;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/akash.take.v1beta3.GenesisState";
+    value: Uint8Array;
+}
+/**
+ * GenesisState stores slice of genesis deployment instance
+ * @name GenesisStateAmino
+ * @package akash.take.v1beta3
+ * @see proto type: akash.take.v1beta3.GenesisState
+ */
+export interface GenesisStateAmino {
+    params: ParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+    type: "/akash.take.v1beta3.GenesisState";
+    value: GenesisStateAmino;
+}
+/**
+ * GenesisState stores slice of genesis deployment instance
+ * @name GenesisState
+ * @package akash.take.v1beta3
+ * @see proto type: akash.take.v1beta3.GenesisState
+ */
+export declare const GenesisState: {
+    typeUrl: string;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};