@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/esm/akash/deployment/v1beta4/groupmsg.js

@@ -0,0 +1,378 @@
+//@ts-nocheck
+import { GroupID } from "../v1/group";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseMsgCloseGroup() {
+    return {
+        id: GroupID.fromPartial({})
+    };
+}
+/**
+ * MsgCloseGroup defines SDK message to close a single Group within a Deployment.
+ * @name MsgCloseGroup
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgCloseGroup
+ */
+export const MsgCloseGroup = {
+    typeUrl: "/akash.deployment.v1beta4.MsgCloseGroup",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            GroupID.encode(message.id, 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 = createBaseMsgCloseGroup();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = GroupID.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCloseGroup();
+        message.id = object.id !== undefined && object.id !== null ? GroupID.fromPartial(object.id) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCloseGroup();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = GroupID.fromAmino(object.id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? GroupID.toAmino(message.id) : GroupID.toAmino(GroupID.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCloseGroup.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCloseGroup.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCloseGroup.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.MsgCloseGroup",
+            value: MsgCloseGroup.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCloseGroupResponse() {
+    return {};
+}
+/**
+ * MsgCloseGroupResponse defines the Msg/CloseGroup response type.
+ * @name MsgCloseGroupResponse
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgCloseGroupResponse
+ */
+export const MsgCloseGroupResponse = {
+    typeUrl: "/akash.deployment.v1beta4.MsgCloseGroupResponse",
+    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 = createBaseMsgCloseGroupResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCloseGroupResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCloseGroupResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCloseGroupResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCloseGroupResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCloseGroupResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.MsgCloseGroupResponse",
+            value: MsgCloseGroupResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgPauseGroup() {
+    return {
+        id: GroupID.fromPartial({})
+    };
+}
+/**
+ * MsgPauseGroup defines SDK message to pause a single Group within a Deployment.
+ * @name MsgPauseGroup
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgPauseGroup
+ */
+export const MsgPauseGroup = {
+    typeUrl: "/akash.deployment.v1beta4.MsgPauseGroup",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            GroupID.encode(message.id, 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 = createBaseMsgPauseGroup();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = GroupID.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgPauseGroup();
+        message.id = object.id !== undefined && object.id !== null ? GroupID.fromPartial(object.id) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgPauseGroup();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = GroupID.fromAmino(object.id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? GroupID.toAmino(message.id) : GroupID.toAmino(GroupID.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgPauseGroup.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgPauseGroup.decode(message.value);
+    },
+    toProto(message) {
+        return MsgPauseGroup.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.MsgPauseGroup",
+            value: MsgPauseGroup.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgPauseGroupResponse() {
+    return {};
+}
+/**
+ * MsgPauseGroupResponse defines the Msg/PauseGroup response type.
+ * @name MsgPauseGroupResponse
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgPauseGroupResponse
+ */
+export const MsgPauseGroupResponse = {
+    typeUrl: "/akash.deployment.v1beta4.MsgPauseGroupResponse",
+    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 = createBaseMsgPauseGroupResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgPauseGroupResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgPauseGroupResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgPauseGroupResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgPauseGroupResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgPauseGroupResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.MsgPauseGroupResponse",
+            value: MsgPauseGroupResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgStartGroup() {
+    return {
+        id: GroupID.fromPartial({})
+    };
+}
+/**
+ * MsgStartGroup defines SDK message to start a single Group within a Deployment.
+ * @name MsgStartGroup
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgStartGroup
+ */
+export const MsgStartGroup = {
+    typeUrl: "/akash.deployment.v1beta4.MsgStartGroup",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            GroupID.encode(message.id, 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 = createBaseMsgStartGroup();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = GroupID.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgStartGroup();
+        message.id = object.id !== undefined && object.id !== null ? GroupID.fromPartial(object.id) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgStartGroup();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = GroupID.fromAmino(object.id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? GroupID.toAmino(message.id) : GroupID.toAmino(GroupID.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgStartGroup.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgStartGroup.decode(message.value);
+    },
+    toProto(message) {
+        return MsgStartGroup.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.MsgStartGroup",
+            value: MsgStartGroup.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgStartGroupResponse() {
+    return {};
+}
+/**
+ * MsgStartGroupResponse defines the Msg/StartGroup response type.
+ * @name MsgStartGroupResponse
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgStartGroupResponse
+ */
+export const MsgStartGroupResponse = {
+    typeUrl: "/akash.deployment.v1beta4.MsgStartGroupResponse",
+    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 = createBaseMsgStartGroupResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgStartGroupResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgStartGroupResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgStartGroupResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgStartGroupResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgStartGroupResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.MsgStartGroupResponse",
+            value: MsgStartGroupResponse.encode(message).finish()
+        };
+    }
+};

package/esm/akash/deployment/v1beta4/groupspec.js

@@ -0,0 +1,101 @@
+//@ts-nocheck
+import { PlacementRequirements } from "../../base/attributes/v1/attribute";
+import { ResourceUnit } from "./resourceunit";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGroupSpec() {
+    return {
+        name: "",
+        requirements: PlacementRequirements.fromPartial({}),
+        resources: []
+    };
+}
+/**
+ * GroupSpec defines a specification for a group in a deployment on the network.
+ * This includes attributes like the group name, placement requirements, and resource units.
+ * @name GroupSpec
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.GroupSpec
+ */
+export const GroupSpec = {
+    typeUrl: "/akash.deployment.v1beta4.GroupSpec",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.requirements !== undefined) {
+            PlacementRequirements.encode(message.requirements, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.resources) {
+            ResourceUnit.encode(v, writer.uint32(26).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 = createBaseGroupSpec();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.requirements = PlacementRequirements.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.resources.push(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 ? PlacementRequirements.fromPartial(object.requirements) : undefined;
+        message.resources = object.resources?.map(e => 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 = PlacementRequirements.fromAmino(object.requirements);
+        }
+        message.resources = object.resources?.map(e => ResourceUnit.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name ?? "";
+        obj.requirements = message.requirements ? PlacementRequirements.toAmino(message.requirements) : PlacementRequirements.toAmino(PlacementRequirements.fromPartial({}));
+        if (message.resources) {
+            obj.resources = message.resources.map(e => e ? ResourceUnit.toAmino(e) : undefined);
+        }
+        else {
+            obj.resources = message.resources;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GroupSpec.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GroupSpec.decode(message.value);
+    },
+    toProto(message) {
+        return GroupSpec.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1beta4.GroupSpec",
+            value: GroupSpec.encode(message).finish()
+        };
+    }
+};

package/esm/akash/deployment/v1beta4/params.js

@@ -0,0 +1,75 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseParams() {
+    return {
+        minDeposits: []
+    };
+}
+/**
+ * Params defines the parameters for the x/deployment module.
+ * @name Params
+ * @package akash.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.Params
+ */
+export const Params = {
+    typeUrl: "/akash.deployment.v1beta4.Params",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.minDeposits) {
+            Coin.encode(v, 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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.minDeposits.push(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.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        message.minDeposits = object.min_deposits?.map(e => Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.minDeposits) {
+            obj.min_deposits = message.minDeposits.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.min_deposits = message.minDeposits;
+        }
+        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.deployment.v1beta4.Params",
+            value: Params.encode(message).finish()
+        };
+    }
+};

package/esm/akash/deployment/v1beta4/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.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/akash.deployment.v1beta4.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.deployment.v1beta4.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.deployment.v1beta4
+ * @see proto type: akash.deployment.v1beta4.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/akash.deployment.v1beta4.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.deployment.v1beta4.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};