@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/akash/deployment/v1beta3/groupspec.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupSpec = void 0;
+//@ts-nocheck
+const attribute_1 = require("../../base/v1beta3/attribute");
+const resourceunit_1 = require("./resourceunit");
+const binary_1 = require("../../../binary");
+function createBaseGroupSpec() {
+    return {
+        name: "",
+        requirements: attribute_1.PlacementRequirements.fromPartial({}),
+        resources: []
+    };
+}
+/**
+ * GroupSpec stores group specifications
+ * @name GroupSpec
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.GroupSpec
+ */
+exports.GroupSpec = {
+    typeUrl: "/akash.deployment.v1beta3.GroupSpec",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.requirements !== undefined) {
+            attribute_1.PlacementRequirements.encode(message.requirements, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.resources) {
+            resourceunit_1.ResourceUnit.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGroupSpec();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.requirements = attribute_1.PlacementRequirements.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.resources.push(resourceunit_1.ResourceUnit.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGroupSpec();
+        message.name = object.name ?? "";
+        message.requirements = object.requirements !== undefined && object.requirements !== null ? attribute_1.PlacementRequirements.fromPartial(object.requirements) : undefined;
+        message.resources = object.resources?.map(e => resourceunit_1.ResourceUnit.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGroupSpec();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.requirements !== undefined && object.requirements !== null) {
+            message.requirements = attribute_1.PlacementRequirements.fromAmino(object.requirements);
+        }
+        message.resources = object.resources?.map(e => resourceunit_1.ResourceUnit.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name ?? "";
+        obj.requirements = message.requirements ? attribute_1.PlacementRequirements.toAmino(message.requirements) : attribute_1.PlacementRequirements.toAmino(attribute_1.PlacementRequirements.fromPartial({}));
+        if (message.resources) {
+            obj.resources = message.resources.map(e => e ? resourceunit_1.ResourceUnit.toAmino(e) : undefined);
+        }
+        else {
+            obj.resources = message.resources;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GroupSpec.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GroupSpec.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GroupSpec.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta3.GroupSpec",
+            value: exports.GroupSpec.encode(message).finish()
+        };
+    }
+};

package/akash/deployment/v1beta3/params.d.ts

@@ -0,0 +1,47 @@
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Params defines the parameters for the x/deployment package
+ * @name Params
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.Params
+ */
+export interface Params {
+    minDeposits: Coin[];
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/akash.deployment.v1beta3.Params";
+    value: Uint8Array;
+}
+/**
+ * Params defines the parameters for the x/deployment package
+ * @name ParamsAmino
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.Params
+ */
+export interface ParamsAmino {
+    min_deposits: CoinAmino[];
+}
+export interface ParamsAminoMsg {
+    type: "/akash.deployment.v1beta3.Params";
+    value: ParamsAmino;
+}
+/**
+ * Params defines the parameters for the x/deployment package
+ * @name Params
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.Params
+ */
+export declare const Params: {
+    typeUrl: string;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};

package/akash/deployment/v1beta3/params.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Params = void 0;
+//@ts-nocheck
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const binary_1 = require("../../../binary");
+function createBaseParams() {
+    return {
+        minDeposits: []
+    };
+}
+/**
+ * Params defines the parameters for the x/deployment package
+ * @name Params
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.Params
+ */
+exports.Params = {
+    typeUrl: "/akash.deployment.v1beta3.Params",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.minDeposits) {
+            coin_1.Coin.encode(v, 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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.minDeposits.push(coin_1.Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.minDeposits = object.minDeposits?.map(e => coin_1.Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        message.minDeposits = object.min_deposits?.map(e => coin_1.Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.minDeposits) {
+            obj.min_deposits = message.minDeposits.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.min_deposits = message.minDeposits;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Params.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Params.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta3.Params",
+            value: exports.Params.encode(message).finish()
+        };
+    }
+};

package/akash/deployment/v1beta3/query.d.ts

@@ -0,0 +1,279 @@
+import { DeploymentFilters, DeploymentFiltersAmino, DeploymentID, DeploymentIDAmino, Deployment, DeploymentAmino } from "./deployment";
+import { PageRequest, PageRequestAmino, PageResponse, PageResponseAmino } from "../../../cosmos/base/query/v1beta1/pagination";
+import { GroupID, GroupIDAmino } from "./groupid";
+import { Group, GroupAmino } from "./group";
+import { Account, AccountAmino } from "../../escrow/v1beta3/types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * QueryDeploymentsRequest is request type for the Query/Deployments RPC method
+ * @name QueryDeploymentsRequest
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentsRequest
+ */
+export interface QueryDeploymentsRequest {
+    filters: DeploymentFilters;
+    pagination?: PageRequest;
+}
+export interface QueryDeploymentsRequestProtoMsg {
+    typeUrl: "/akash.deployment.v1beta3.QueryDeploymentsRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryDeploymentsRequest is request type for the Query/Deployments RPC method
+ * @name QueryDeploymentsRequestAmino
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentsRequest
+ */
+export interface QueryDeploymentsRequestAmino {
+    filters?: DeploymentFiltersAmino;
+    pagination?: PageRequestAmino;
+}
+export interface QueryDeploymentsRequestAminoMsg {
+    type: "/akash.deployment.v1beta3.QueryDeploymentsRequest";
+    value: QueryDeploymentsRequestAmino;
+}
+/**
+ * QueryDeploymentsResponse is response type for the Query/Deployments RPC method
+ * @name QueryDeploymentsResponse
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentsResponse
+ */
+export interface QueryDeploymentsResponse {
+    deployments: QueryDeploymentResponse[];
+    pagination?: PageResponse;
+}
+export interface QueryDeploymentsResponseProtoMsg {
+    typeUrl: "/akash.deployment.v1beta3.QueryDeploymentsResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryDeploymentsResponse is response type for the Query/Deployments RPC method
+ * @name QueryDeploymentsResponseAmino
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentsResponse
+ */
+export interface QueryDeploymentsResponseAmino {
+    deployments?: QueryDeploymentResponseAmino[];
+    pagination?: PageResponseAmino;
+}
+export interface QueryDeploymentsResponseAminoMsg {
+    type: "/akash.deployment.v1beta3.QueryDeploymentsResponse";
+    value: QueryDeploymentsResponseAmino;
+}
+/**
+ * QueryDeploymentRequest is request type for the Query/Deployment RPC method
+ * @name QueryDeploymentRequest
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentRequest
+ */
+export interface QueryDeploymentRequest {
+    id: DeploymentID;
+}
+export interface QueryDeploymentRequestProtoMsg {
+    typeUrl: "/akash.deployment.v1beta3.QueryDeploymentRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryDeploymentRequest is request type for the Query/Deployment RPC method
+ * @name QueryDeploymentRequestAmino
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentRequest
+ */
+export interface QueryDeploymentRequestAmino {
+    id?: DeploymentIDAmino;
+}
+export interface QueryDeploymentRequestAminoMsg {
+    type: "/akash.deployment.v1beta3.QueryDeploymentRequest";
+    value: QueryDeploymentRequestAmino;
+}
+/**
+ * QueryDeploymentResponse is response type for the Query/Deployment RPC method
+ * @name QueryDeploymentResponse
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentResponse
+ */
+export interface QueryDeploymentResponse {
+    deployment: Deployment;
+    groups: Group[];
+    escrowAccount: Account;
+}
+export interface QueryDeploymentResponseProtoMsg {
+    typeUrl: "/akash.deployment.v1beta3.QueryDeploymentResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryDeploymentResponse is response type for the Query/Deployment RPC method
+ * @name QueryDeploymentResponseAmino
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentResponse
+ */
+export interface QueryDeploymentResponseAmino {
+    deployment: DeploymentAmino;
+    groups: GroupAmino[];
+    escrow_account?: AccountAmino;
+}
+export interface QueryDeploymentResponseAminoMsg {
+    type: "/akash.deployment.v1beta3.QueryDeploymentResponse";
+    value: QueryDeploymentResponseAmino;
+}
+/**
+ * QueryGroupRequest is request type for the Query/Group RPC method
+ * @name QueryGroupRequest
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryGroupRequest
+ */
+export interface QueryGroupRequest {
+    id: GroupID;
+}
+export interface QueryGroupRequestProtoMsg {
+    typeUrl: "/akash.deployment.v1beta3.QueryGroupRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryGroupRequest is request type for the Query/Group RPC method
+ * @name QueryGroupRequestAmino
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryGroupRequest
+ */
+export interface QueryGroupRequestAmino {
+    id?: GroupIDAmino;
+}
+export interface QueryGroupRequestAminoMsg {
+    type: "/akash.deployment.v1beta3.QueryGroupRequest";
+    value: QueryGroupRequestAmino;
+}
+/**
+ * QueryGroupResponse is response type for the Query/Group RPC method
+ * @name QueryGroupResponse
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryGroupResponse
+ */
+export interface QueryGroupResponse {
+    group: Group;
+}
+export interface QueryGroupResponseProtoMsg {
+    typeUrl: "/akash.deployment.v1beta3.QueryGroupResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryGroupResponse is response type for the Query/Group RPC method
+ * @name QueryGroupResponseAmino
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryGroupResponse
+ */
+export interface QueryGroupResponseAmino {
+    group?: GroupAmino;
+}
+export interface QueryGroupResponseAminoMsg {
+    type: "/akash.deployment.v1beta3.QueryGroupResponse";
+    value: QueryGroupResponseAmino;
+}
+/**
+ * QueryDeploymentsRequest is request type for the Query/Deployments RPC method
+ * @name QueryDeploymentsRequest
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentsRequest
+ */
+export declare const QueryDeploymentsRequest: {
+    typeUrl: string;
+    encode(message: QueryDeploymentsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryDeploymentsRequest;
+    fromPartial(object: DeepPartial<QueryDeploymentsRequest>): QueryDeploymentsRequest;
+    fromAmino(object: QueryDeploymentsRequestAmino): QueryDeploymentsRequest;
+    toAmino(message: QueryDeploymentsRequest): QueryDeploymentsRequestAmino;
+    fromAminoMsg(object: QueryDeploymentsRequestAminoMsg): QueryDeploymentsRequest;
+    fromProtoMsg(message: QueryDeploymentsRequestProtoMsg): QueryDeploymentsRequest;
+    toProto(message: QueryDeploymentsRequest): Uint8Array;
+    toProtoMsg(message: QueryDeploymentsRequest): QueryDeploymentsRequestProtoMsg;
+};
+/**
+ * QueryDeploymentsResponse is response type for the Query/Deployments RPC method
+ * @name QueryDeploymentsResponse
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentsResponse
+ */
+export declare const QueryDeploymentsResponse: {
+    typeUrl: string;
+    encode(message: QueryDeploymentsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryDeploymentsResponse;
+    fromPartial(object: DeepPartial<QueryDeploymentsResponse>): QueryDeploymentsResponse;
+    fromAmino(object: QueryDeploymentsResponseAmino): QueryDeploymentsResponse;
+    toAmino(message: QueryDeploymentsResponse): QueryDeploymentsResponseAmino;
+    fromAminoMsg(object: QueryDeploymentsResponseAminoMsg): QueryDeploymentsResponse;
+    fromProtoMsg(message: QueryDeploymentsResponseProtoMsg): QueryDeploymentsResponse;
+    toProto(message: QueryDeploymentsResponse): Uint8Array;
+    toProtoMsg(message: QueryDeploymentsResponse): QueryDeploymentsResponseProtoMsg;
+};
+/**
+ * QueryDeploymentRequest is request type for the Query/Deployment RPC method
+ * @name QueryDeploymentRequest
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentRequest
+ */
+export declare const QueryDeploymentRequest: {
+    typeUrl: string;
+    encode(message: QueryDeploymentRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryDeploymentRequest;
+    fromPartial(object: DeepPartial<QueryDeploymentRequest>): QueryDeploymentRequest;
+    fromAmino(object: QueryDeploymentRequestAmino): QueryDeploymentRequest;
+    toAmino(message: QueryDeploymentRequest): QueryDeploymentRequestAmino;
+    fromAminoMsg(object: QueryDeploymentRequestAminoMsg): QueryDeploymentRequest;
+    fromProtoMsg(message: QueryDeploymentRequestProtoMsg): QueryDeploymentRequest;
+    toProto(message: QueryDeploymentRequest): Uint8Array;
+    toProtoMsg(message: QueryDeploymentRequest): QueryDeploymentRequestProtoMsg;
+};
+/**
+ * QueryDeploymentResponse is response type for the Query/Deployment RPC method
+ * @name QueryDeploymentResponse
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryDeploymentResponse
+ */
+export declare const QueryDeploymentResponse: {
+    typeUrl: string;
+    encode(message: QueryDeploymentResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryDeploymentResponse;
+    fromPartial(object: DeepPartial<QueryDeploymentResponse>): QueryDeploymentResponse;
+    fromAmino(object: QueryDeploymentResponseAmino): QueryDeploymentResponse;
+    toAmino(message: QueryDeploymentResponse): QueryDeploymentResponseAmino;
+    fromAminoMsg(object: QueryDeploymentResponseAminoMsg): QueryDeploymentResponse;
+    fromProtoMsg(message: QueryDeploymentResponseProtoMsg): QueryDeploymentResponse;
+    toProto(message: QueryDeploymentResponse): Uint8Array;
+    toProtoMsg(message: QueryDeploymentResponse): QueryDeploymentResponseProtoMsg;
+};
+/**
+ * QueryGroupRequest is request type for the Query/Group RPC method
+ * @name QueryGroupRequest
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryGroupRequest
+ */
+export declare const QueryGroupRequest: {
+    typeUrl: string;
+    encode(message: QueryGroupRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryGroupRequest;
+    fromPartial(object: DeepPartial<QueryGroupRequest>): QueryGroupRequest;
+    fromAmino(object: QueryGroupRequestAmino): QueryGroupRequest;
+    toAmino(message: QueryGroupRequest): QueryGroupRequestAmino;
+    fromAminoMsg(object: QueryGroupRequestAminoMsg): QueryGroupRequest;
+    fromProtoMsg(message: QueryGroupRequestProtoMsg): QueryGroupRequest;
+    toProto(message: QueryGroupRequest): Uint8Array;
+    toProtoMsg(message: QueryGroupRequest): QueryGroupRequestProtoMsg;
+};
+/**
+ * QueryGroupResponse is response type for the Query/Group RPC method
+ * @name QueryGroupResponse
+ * @package akash.deployment.v1beta3
+ * @see proto type: akash.deployment.v1beta3.QueryGroupResponse
+ */
+export declare const QueryGroupResponse: {
+    typeUrl: string;
+    encode(message: QueryGroupResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryGroupResponse;
+    fromPartial(object: DeepPartial<QueryGroupResponse>): QueryGroupResponse;
+    fromAmino(object: QueryGroupResponseAmino): QueryGroupResponse;
+    toAmino(message: QueryGroupResponse): QueryGroupResponseAmino;
+    fromAminoMsg(object: QueryGroupResponseAminoMsg): QueryGroupResponse;
+    fromProtoMsg(message: QueryGroupResponseProtoMsg): QueryGroupResponse;
+    toProto(message: QueryGroupResponse): Uint8Array;
+    toProtoMsg(message: QueryGroupResponse): QueryGroupResponseProtoMsg;
+};