@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/esm/akash/base/resources/v1beta4/memory.js

@@ -0,0 +1,88 @@
+//@ts-nocheck
+import { ResourceValue } from "./resourcevalue";
+import { Attribute } from "../../attributes/v1/attribute";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseMemory() {
+    return {
+        quantity: ResourceValue.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * Memory stores resource quantity and memory attributes.
+ * @name Memory
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Memory
+ */
+export const Memory = {
+    typeUrl: "/akash.base.resources.v1beta4.Memory",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.quantity !== undefined) {
+            ResourceValue.encode(message.quantity, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            Attribute.encode(v, 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 = createBaseMemory();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.quantity = ResourceValue.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.attributes.push(Attribute.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMemory();
+        message.quantity = object.quantity !== undefined && object.quantity !== null ? ResourceValue.fromPartial(object.quantity) : undefined;
+        message.attributes = object.attributes?.map(e => Attribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMemory();
+        if (object.quantity !== undefined && object.quantity !== null) {
+            message.quantity = ResourceValue.fromAmino(object.quantity);
+        }
+        message.attributes = object.attributes?.map(e => Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.quantity = message.quantity ? ResourceValue.toAmino(message.quantity) : ResourceValue.toAmino(ResourceValue.fromPartial({}));
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? Attribute.toAmino(e) : undefined);
+        }
+        else {
+            obj.attributes = message.attributes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Memory.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Memory.decode(message.value);
+    },
+    toProto(message) {
+        return Memory.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.resources.v1beta4.Memory",
+            value: Memory.encode(message).finish()
+        };
+    }
+};

package/esm/akash/base/resources/v1beta4/resources.js

@@ -0,0 +1,143 @@
+//@ts-nocheck
+import { CPU } from "./cpu";
+import { Memory } from "./memory";
+import { Storage } from "./storage";
+import { GPU } from "./gpu";
+import { Endpoint } from "./endpoint";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseResources() {
+    return {
+        id: 0,
+        cpu: undefined,
+        memory: undefined,
+        storage: [],
+        gpu: undefined,
+        endpoints: []
+    };
+}
+/**
+ * Resources describes all available resources types for deployment/node etc
+ * if field is nil resource is not present in the given data-structure
+ * @name Resources
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Resources
+ */
+export const Resources = {
+    typeUrl: "/akash.base.resources.v1beta4.Resources",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== 0) {
+            writer.uint32(8).uint32(message.id);
+        }
+        if (message.cpu !== undefined) {
+            CPU.encode(message.cpu, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.memory !== undefined) {
+            Memory.encode(message.memory, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.storage) {
+            Storage.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.gpu !== undefined) {
+            GPU.encode(message.gpu, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.endpoints) {
+            Endpoint.encode(v, writer.uint32(50).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 = createBaseResources();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint32();
+                    break;
+                case 2:
+                    message.cpu = CPU.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.memory = Memory.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.storage.push(Storage.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.gpu = GPU.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.endpoints.push(Endpoint.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseResources();
+        message.id = object.id ?? 0;
+        message.cpu = object.cpu !== undefined && object.cpu !== null ? CPU.fromPartial(object.cpu) : undefined;
+        message.memory = object.memory !== undefined && object.memory !== null ? Memory.fromPartial(object.memory) : undefined;
+        message.storage = object.storage?.map(e => Storage.fromPartial(e)) || [];
+        message.gpu = object.gpu !== undefined && object.gpu !== null ? GPU.fromPartial(object.gpu) : undefined;
+        message.endpoints = object.endpoints?.map(e => Endpoint.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseResources();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = object.id;
+        }
+        if (object.cpu !== undefined && object.cpu !== null) {
+            message.cpu = CPU.fromAmino(object.cpu);
+        }
+        if (object.memory !== undefined && object.memory !== null) {
+            message.memory = Memory.fromAmino(object.memory);
+        }
+        message.storage = object.storage?.map(e => Storage.fromAmino(e)) || [];
+        if (object.gpu !== undefined && object.gpu !== null) {
+            message.gpu = GPU.fromAmino(object.gpu);
+        }
+        message.endpoints = object.endpoints?.map(e => Endpoint.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ?? 0;
+        obj.cpu = message.cpu ? CPU.toAmino(message.cpu) : undefined;
+        obj.memory = message.memory ? Memory.toAmino(message.memory) : undefined;
+        if (message.storage) {
+            obj.storage = message.storage.map(e => e ? Storage.toAmino(e) : undefined);
+        }
+        else {
+            obj.storage = message.storage;
+        }
+        obj.gpu = message.gpu ? GPU.toAmino(message.gpu) : undefined;
+        if (message.endpoints) {
+            obj.endpoints = message.endpoints.map(e => e ? Endpoint.toAmino(e) : undefined);
+        }
+        else {
+            obj.endpoints = message.endpoints;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Resources.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Resources.decode(message.value);
+    },
+    toProto(message) {
+        return Resources.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.resources.v1beta4.Resources",
+            value: Resources.encode(message).finish()
+        };
+    }
+};

package/esm/akash/base/resources/v1beta4/resourcevalue.js

@@ -0,0 +1,72 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+function createBaseResourceValue() {
+    return {
+        val: new Uint8Array()
+    };
+}
+/**
+ * Unit stores cpu, memory and storage metrics.
+ * @name ResourceValue
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.ResourceValue
+ */
+export const ResourceValue = {
+    typeUrl: "/akash.base.resources.v1beta4.ResourceValue",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.val.length !== 0) {
+            writer.uint32(10).bytes(message.val);
+        }
+        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 = createBaseResourceValue();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.val = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseResourceValue();
+        message.val = object.val ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseResourceValue();
+        if (object.val !== undefined && object.val !== null) {
+            message.val = bytesFromBase64(object.val);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.val = message.val ? base64FromBytes(message.val) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ResourceValue.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ResourceValue.decode(message.value);
+    },
+    toProto(message) {
+        return ResourceValue.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.resources.v1beta4.ResourceValue",
+            value: ResourceValue.encode(message).finish()
+        };
+    }
+};

package/esm/akash/base/resources/v1beta4/storage.js

@@ -0,0 +1,100 @@
+//@ts-nocheck
+import { ResourceValue } from "./resourcevalue";
+import { Attribute } from "../../attributes/v1/attribute";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseStorage() {
+    return {
+        name: "",
+        quantity: ResourceValue.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * Storage stores resource quantity and storage attributes.
+ * @name Storage
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Storage
+ */
+export const Storage = {
+    typeUrl: "/akash.base.resources.v1beta4.Storage",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.quantity !== undefined) {
+            ResourceValue.encode(message.quantity, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            Attribute.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 = createBaseStorage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.quantity = ResourceValue.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.attributes.push(Attribute.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseStorage();
+        message.name = object.name ?? "";
+        message.quantity = object.quantity !== undefined && object.quantity !== null ? ResourceValue.fromPartial(object.quantity) : undefined;
+        message.attributes = object.attributes?.map(e => Attribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseStorage();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.quantity !== undefined && object.quantity !== null) {
+            message.quantity = ResourceValue.fromAmino(object.quantity);
+        }
+        message.attributes = object.attributes?.map(e => Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name ?? "";
+        obj.quantity = message.quantity ? ResourceValue.toAmino(message.quantity) : ResourceValue.toAmino(ResourceValue.fromPartial({}));
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? Attribute.toAmino(e) : undefined);
+        }
+        else {
+            obj.attributes = message.attributes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Storage.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Storage.decode(message.value);
+    },
+    toProto(message) {
+        return Storage.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.resources.v1beta4.Storage",
+            value: Storage.encode(message).finish()
+        };
+    }
+};

package/esm/akash/base/v1beta3/attribute.js

@@ -0,0 +1,257 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseAttribute() {
+    return {
+        key: "",
+        value: ""
+    };
+}
+/**
+ * Attribute represents key value pair
+ * @name Attribute
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Attribute
+ */
+export const Attribute = {
+    typeUrl: "/akash.base.v1beta3.Attribute",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        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 = createBaseAttribute();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAttribute();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAttribute();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = object.key;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key === "" ? undefined : message.key;
+        obj.value = message.value === "" ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Attribute.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Attribute.decode(message.value);
+    },
+    toProto(message) {
+        return Attribute.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.v1beta3.Attribute",
+            value: Attribute.encode(message).finish()
+        };
+    }
+};
+function createBaseSignedBy() {
+    return {
+        allOf: [],
+        anyOf: []
+    };
+}
+/**
+ * SignedBy represents validation accounts that tenant expects signatures for provider attributes
+ * AllOf has precedence i.e. if there is at least one entry AnyOf is ignored regardless to how many
+ * entries there
+ * this behaviour to be discussed
+ * @name SignedBy
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.SignedBy
+ */
+export const SignedBy = {
+    typeUrl: "/akash.base.v1beta3.SignedBy",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.allOf) {
+            writer.uint32(10).string(v);
+        }
+        for (const v of message.anyOf) {
+            writer.uint32(18).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 = createBaseSignedBy();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.allOf.push(reader.string());
+                    break;
+                case 2:
+                    message.anyOf.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSignedBy();
+        message.allOf = object.allOf?.map(e => e) || [];
+        message.anyOf = object.anyOf?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSignedBy();
+        message.allOf = object.all_of?.map(e => e) || [];
+        message.anyOf = object.any_of?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.allOf) {
+            obj.all_of = message.allOf.map(e => e);
+        }
+        else {
+            obj.all_of = message.allOf;
+        }
+        if (message.anyOf) {
+            obj.any_of = message.anyOf.map(e => e);
+        }
+        else {
+            obj.any_of = message.anyOf;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SignedBy.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SignedBy.decode(message.value);
+    },
+    toProto(message) {
+        return SignedBy.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.v1beta3.SignedBy",
+            value: SignedBy.encode(message).finish()
+        };
+    }
+};
+function createBasePlacementRequirements() {
+    return {
+        signedBy: SignedBy.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * PlacementRequirements
+ * @name PlacementRequirements
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.PlacementRequirements
+ */
+export const PlacementRequirements = {
+    typeUrl: "/akash.base.v1beta3.PlacementRequirements",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signedBy !== undefined) {
+            SignedBy.encode(message.signedBy, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            Attribute.encode(v, 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 = createBasePlacementRequirements();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signedBy = SignedBy.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.attributes.push(Attribute.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePlacementRequirements();
+        message.signedBy = object.signedBy !== undefined && object.signedBy !== null ? SignedBy.fromPartial(object.signedBy) : undefined;
+        message.attributes = object.attributes?.map(e => Attribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePlacementRequirements();
+        if (object.signed_by !== undefined && object.signed_by !== null) {
+            message.signedBy = SignedBy.fromAmino(object.signed_by);
+        }
+        message.attributes = object.attributes?.map(e => Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signed_by = message.signedBy ? SignedBy.toAmino(message.signedBy) : SignedBy.toAmino(SignedBy.fromPartial({}));
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? Attribute.toAmino(e) : undefined);
+        }
+        else {
+            obj.attributes = message.attributes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PlacementRequirements.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PlacementRequirements.decode(message.value);
+    },
+    toProto(message) {
+        return PlacementRequirements.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.v1beta3.PlacementRequirements",
+            value: PlacementRequirements.encode(message).finish()
+        };
+    }
+};