@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/akash/deployment/v1beta4/filters.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupFilters = exports.DeploymentFilters = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseDeploymentFilters() {
+    return {
+        owner: "",
+        dseq: BigInt(0),
+        state: ""
+    };
+}
+/**
+ * DeploymentFilters defines filters used to filter deployments.
+ * @name DeploymentFilters
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.DeploymentFilters
+ */
+exports.DeploymentFilters = {
+    typeUrl: "/akash.deployment.v1beta4.DeploymentFilters",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.dseq !== BigInt(0)) {
+            writer.uint32(16).uint64(message.dseq);
+        }
+        if (message.state !== "") {
+            writer.uint32(26).string(message.state);
+        }
+        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 = createBaseDeploymentFilters();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.dseq = reader.uint64();
+                    break;
+                case 3:
+                    message.state = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDeploymentFilters();
+        message.owner = object.owner ?? "";
+        message.dseq = object.dseq !== undefined && object.dseq !== null ? BigInt(object.dseq.toString()) : BigInt(0);
+        message.state = object.state ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDeploymentFilters();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.dseq !== undefined && object.dseq !== null) {
+            message.dseq = BigInt(object.dseq);
+        }
+        if (object.state !== undefined && object.state !== null) {
+            message.state = object.state;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.dseq = message.dseq ? message.dseq?.toString() : "0";
+        obj.state = message.state ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.DeploymentFilters.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.DeploymentFilters.decode(message.value);
+    },
+    toProto(message) {
+        return exports.DeploymentFilters.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.DeploymentFilters",
+            value: exports.DeploymentFilters.encode(message).finish()
+        };
+    }
+};
+function createBaseGroupFilters() {
+    return {
+        owner: "",
+        dseq: BigInt(0),
+        gseq: BigInt(0),
+        state: ""
+    };
+}
+/**
+ * GroupFilters defines filters used to filter groups
+ * @name GroupFilters
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GroupFilters
+ */
+exports.GroupFilters = {
+    typeUrl: "/akash.deployment.v1beta4.GroupFilters",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.dseq !== BigInt(0)) {
+            writer.uint32(16).uint64(message.dseq);
+        }
+        if (message.gseq !== BigInt(0)) {
+            writer.uint32(24).uint64(message.gseq);
+        }
+        if (message.state !== "") {
+            writer.uint32(34).string(message.state);
+        }
+        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 = createBaseGroupFilters();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.dseq = reader.uint64();
+                    break;
+                case 3:
+                    message.gseq = reader.uint64();
+                    break;
+                case 4:
+                    message.state = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGroupFilters();
+        message.owner = object.owner ?? "";
+        message.dseq = object.dseq !== undefined && object.dseq !== null ? BigInt(object.dseq.toString()) : BigInt(0);
+        message.gseq = object.gseq !== undefined && object.gseq !== null ? BigInt(object.gseq.toString()) : BigInt(0);
+        message.state = object.state ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGroupFilters();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.dseq !== undefined && object.dseq !== null) {
+            message.dseq = BigInt(object.dseq);
+        }
+        if (object.gseq !== undefined && object.gseq !== null) {
+            message.gseq = BigInt(object.gseq);
+        }
+        if (object.state !== undefined && object.state !== null) {
+            message.state = object.state;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.dseq = message.dseq ? message.dseq?.toString() : "0";
+        obj.gseq = message.gseq ? message.gseq?.toString() : "0";
+        obj.state = message.state ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GroupFilters.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GroupFilters.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GroupFilters.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.GroupFilters",
+            value: exports.GroupFilters.encode(message).finish()
+        };
+    }
+};

package/akash/deployment/v1beta4/genesis.d.ts

@@ -0,0 +1,121 @@
+import { Deployment, DeploymentAmino } from "../v1/deployment";
+import { Group, GroupAmino } from "./group";
+import { Params, ParamsAmino } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * GenesisDeployment defines the basic genesis state used by deployment module.
+ * @name GenesisDeployment
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GenesisDeployment
+ */
+export interface GenesisDeployment {
+    /**
+     * Deployments represents a deployment on the network.
+     */
+    deployment: Deployment;
+    /**
+     * Groups is a list of groups within a Deployment.
+     */
+    groups: Group[];
+}
+export interface GenesisDeploymentProtoMsg {
+    typeUrl: "/akash.deployment.v1beta4.GenesisDeployment";
+    value: Uint8Array;
+}
+/**
+ * GenesisDeployment defines the basic genesis state used by deployment module.
+ * @name GenesisDeploymentAmino
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GenesisDeployment
+ */
+export interface GenesisDeploymentAmino {
+    /**
+     * Deployments represents a deployment on the network.
+     */
+    deployment: DeploymentAmino;
+    /**
+     * Groups is a list of groups within a Deployment.
+     */
+    groups: GroupAmino[];
+}
+export interface GenesisDeploymentAminoMsg {
+    type: "/akash.deployment.v1beta4.GenesisDeployment";
+    value: GenesisDeploymentAmino;
+}
+/**
+ * GenesisState stores slice of genesis deployment instance.
+ * @name GenesisState
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GenesisState
+ */
+export interface GenesisState {
+    /**
+     * Deployments is a list of deployments on the network.
+     */
+    deployments: GenesisDeployment[];
+    /**
+     * Params defines the parameters for the x/deployment module.
+     */
+    params: Params;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/akash.deployment.v1beta4.GenesisState";
+    value: Uint8Array;
+}
+/**
+ * GenesisState stores slice of genesis deployment instance.
+ * @name GenesisStateAmino
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GenesisState
+ */
+export interface GenesisStateAmino {
+    /**
+     * Deployments is a list of deployments on the network.
+     */
+    deployments: GenesisDeploymentAmino[];
+    /**
+     * Params defines the parameters for the x/deployment module.
+     */
+    params: ParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+    type: "/akash.deployment.v1beta4.GenesisState";
+    value: GenesisStateAmino;
+}
+/**
+ * GenesisDeployment defines the basic genesis state used by deployment module.
+ * @name GenesisDeployment
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GenesisDeployment
+ */
+export declare const GenesisDeployment: {
+    typeUrl: string;
+    encode(message: GenesisDeployment, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisDeployment;
+    fromPartial(object: DeepPartial<GenesisDeployment>): GenesisDeployment;
+    fromAmino(object: GenesisDeploymentAmino): GenesisDeployment;
+    toAmino(message: GenesisDeployment): GenesisDeploymentAmino;
+    fromAminoMsg(object: GenesisDeploymentAminoMsg): GenesisDeployment;
+    fromProtoMsg(message: GenesisDeploymentProtoMsg): GenesisDeployment;
+    toProto(message: GenesisDeployment): Uint8Array;
+    toProtoMsg(message: GenesisDeployment): GenesisDeploymentProtoMsg;
+};
+/**
+ * GenesisState stores slice of genesis deployment instance.
+ * @name GenesisState
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.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;
+};

package/akash/deployment/v1beta4/genesis.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = exports.GenesisDeployment = void 0;
+//@ts-nocheck
+const deployment_1 = require("../v1/deployment");
+const group_1 = require("./group");
+const params_1 = require("./params");
+const binary_1 = require("../../../binary");
+function createBaseGenesisDeployment() {
+    return {
+        deployment: deployment_1.Deployment.fromPartial({}),
+        groups: []
+    };
+}
+/**
+ * GenesisDeployment defines the basic genesis state used by deployment module.
+ * @name GenesisDeployment
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GenesisDeployment
+ */
+exports.GenesisDeployment = {
+    typeUrl: "/akash.deployment.v1beta4.GenesisDeployment",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.deployment !== undefined) {
+            deployment_1.Deployment.encode(message.deployment, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.groups) {
+            group_1.Group.encode(v, 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 = createBaseGenesisDeployment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.deployment = deployment_1.Deployment.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.groups.push(group_1.Group.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisDeployment();
+        message.deployment = object.deployment !== undefined && object.deployment !== null ? deployment_1.Deployment.fromPartial(object.deployment) : undefined;
+        message.groups = object.groups?.map(e => group_1.Group.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisDeployment();
+        if (object.deployment !== undefined && object.deployment !== null) {
+            message.deployment = deployment_1.Deployment.fromAmino(object.deployment);
+        }
+        message.groups = object.groups?.map(e => group_1.Group.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.deployment = message.deployment ? deployment_1.Deployment.toAmino(message.deployment) : deployment_1.Deployment.toAmino(deployment_1.Deployment.fromPartial({}));
+        if (message.groups) {
+            obj.groups = message.groups.map(e => e ? group_1.Group.toAmino(e) : undefined);
+        }
+        else {
+            obj.groups = message.groups;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisDeployment.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisDeployment.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisDeployment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.GenesisDeployment",
+            value: exports.GenesisDeployment.encode(message).finish()
+        };
+    }
+};
+function createBaseGenesisState() {
+    return {
+        deployments: [],
+        params: params_1.Params.fromPartial({})
+    };
+}
+/**
+ * GenesisState stores slice of genesis deployment instance.
+ * @name GenesisState
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GenesisState
+ */
+exports.GenesisState = {
+    typeUrl: "/akash.deployment.v1beta4.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.deployments) {
+            exports.GenesisDeployment.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.deployments.push(exports.GenesisDeployment.decode(reader, reader.uint32()));
+                    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 = createBaseGenesisState();
+        message.deployments = object.deployments?.map(e => exports.GenesisDeployment.fromPartial(e)) || [];
+        message.params = object.params !== undefined && object.params !== null ? params_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.deployments = object.deployments?.map(e => exports.GenesisDeployment.fromAmino(e)) || [];
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.deployments) {
+            obj.deployments = message.deployments.map(e => e ? exports.GenesisDeployment.toAmino(e) : undefined);
+        }
+        else {
+            obj.deployments = message.deployments;
+        }
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : params_1.Params.toAmino(params_1.Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};

package/akash/deployment/v1beta4/group.d.ts

@@ -0,0 +1,95 @@
+import { GroupID, GroupIDAmino } from "../v1/group";
+import { GroupSpec, GroupSpecAmino } from "./groupspec";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** State is an enum which refers to state of group. */
+export declare enum Group_State {
+    /** invalid - Prefix should start with 0 in enum. So declaring dummy state. */
+    invalid = 0,
+    /** open - GroupOpen denotes state for group open. */
+    open = 1,
+    /** paused - GroupOrdered denotes state for group ordered. */
+    paused = 2,
+    /** insufficient_funds - GroupInsufficientFunds denotes state for group insufficient_funds. */
+    insufficient_funds = 3,
+    /** closed - GroupClosed denotes state for group closed. */
+    closed = 4,
+    UNRECOGNIZED = -1
+}
+export declare const Group_StateAmino: typeof Group_State;
+export declare function group_StateFromJSON(object: any): Group_State;
+export declare function group_StateToJSON(object: Group_State): string;
+/**
+ * Group stores group id, state and specifications of a group.
+ * @name Group
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.Group
+ */
+export interface Group {
+    /**
+     * Id is the unique identifier for the group.
+     */
+    id: GroupID;
+    /**
+     * State represents the state of the group.
+     */
+    state: Group_State;
+    /**
+     * GroupSpec holds the specification of a the Group.
+     */
+    groupSpec: GroupSpec;
+    /**
+     * CreatedAt is the block height at which the deployment was created.
+     */
+    createdAt: bigint;
+}
+export interface GroupProtoMsg {
+    typeUrl: "/akash.deployment.v1beta4.Group";
+    value: Uint8Array;
+}
+/**
+ * Group stores group id, state and specifications of a group.
+ * @name GroupAmino
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.Group
+ */
+export interface GroupAmino {
+    /**
+     * Id is the unique identifier for the group.
+     */
+    id: GroupIDAmino;
+    /**
+     * State represents the state of the group.
+     */
+    state: Group_State;
+    /**
+     * GroupSpec holds the specification of a the Group.
+     */
+    group_spec: GroupSpecAmino;
+    /**
+     * CreatedAt is the block height at which the deployment was created.
+     */
+    created_at?: string;
+}
+export interface GroupAminoMsg {
+    type: "/akash.deployment.v1beta4.Group";
+    value: GroupAmino;
+}
+/**
+ * Group stores group id, state and specifications of a group.
+ * @name Group
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.Group
+ */
+export declare const Group: {
+    typeUrl: string;
+    encode(message: Group, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Group;
+    fromPartial(object: DeepPartial<Group>): Group;
+    fromAmino(object: GroupAmino): Group;
+    toAmino(message: Group): GroupAmino;
+    fromAminoMsg(object: GroupAminoMsg): Group;
+    fromProtoMsg(message: GroupProtoMsg): Group;
+    toProto(message: Group): Uint8Array;
+    toProtoMsg(message: Group): GroupProtoMsg;
+};