@sparkdreamnft/sparkdreamjs 0.0.27 → 0.0.29

package/akash/base/v1beta3/gpu.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GPU = void 0;
+//@ts-nocheck
+const resourcevalue_1 = require("./resourcevalue");
+const attribute_1 = require("./attribute");
+const binary_1 = require("../../../binary");
+function createBaseGPU() {
+    return {
+        units: resourcevalue_1.ResourceValue.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * GPU stores resource units and cpu config attributes
+ * @name GPU
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.GPU
+ */
+exports.GPU = {
+    typeUrl: "/akash.base.v1beta3.GPU",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.units !== undefined) {
+            resourcevalue_1.ResourceValue.encode(message.units, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            attribute_1.Attribute.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 = createBaseGPU();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.units = resourcevalue_1.ResourceValue.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.attributes.push(attribute_1.Attribute.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGPU();
+        message.units = object.units !== undefined && object.units !== null ? resourcevalue_1.ResourceValue.fromPartial(object.units) : undefined;
+        message.attributes = object.attributes?.map(e => attribute_1.Attribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGPU();
+        if (object.units !== undefined && object.units !== null) {
+            message.units = resourcevalue_1.ResourceValue.fromAmino(object.units);
+        }
+        message.attributes = object.attributes?.map(e => attribute_1.Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.units = message.units ? resourcevalue_1.ResourceValue.toAmino(message.units) : undefined;
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? attribute_1.Attribute.toAmino(e) : undefined);
+        }
+        else {
+            obj.attributes = message.attributes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GPU.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GPU.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GPU.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.v1beta3.GPU",
+            value: exports.GPU.encode(message).finish()
+        };
+    }
+};

package/akash/base/v1beta3/memory.d.ts

@@ -0,0 +1,50 @@
+import { ResourceValue, ResourceValueAmino } from "./resourcevalue";
+import { Attribute, AttributeAmino } from "./attribute";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Memory stores resource quantity and memory attributes
+ * @name Memory
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Memory
+ */
+export interface Memory {
+    quantity: ResourceValue;
+    attributes: Attribute[];
+}
+export interface MemoryProtoMsg {
+    typeUrl: "/akash.base.v1beta3.Memory";
+    value: Uint8Array;
+}
+/**
+ * Memory stores resource quantity and memory attributes
+ * @name MemoryAmino
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Memory
+ */
+export interface MemoryAmino {
+    quantity: ResourceValueAmino;
+    attributes?: AttributeAmino[];
+}
+export interface MemoryAminoMsg {
+    type: "/akash.base.v1beta3.Memory";
+    value: MemoryAmino;
+}
+/**
+ * Memory stores resource quantity and memory attributes
+ * @name Memory
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Memory
+ */
+export declare const Memory: {
+    typeUrl: string;
+    encode(message: Memory, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Memory;
+    fromPartial(object: DeepPartial<Memory>): Memory;
+    fromAmino(object: MemoryAmino): Memory;
+    toAmino(message: Memory): MemoryAmino;
+    fromAminoMsg(object: MemoryAminoMsg): Memory;
+    fromProtoMsg(message: MemoryProtoMsg): Memory;
+    toProto(message: Memory): Uint8Array;
+    toProtoMsg(message: Memory): MemoryProtoMsg;
+};

package/akash/base/v1beta3/memory.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+//@ts-nocheck
+const resourcevalue_1 = require("./resourcevalue");
+const attribute_1 = require("./attribute");
+const binary_1 = require("../../../binary");
+function createBaseMemory() {
+    return {
+        quantity: resourcevalue_1.ResourceValue.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * Memory stores resource quantity and memory attributes
+ * @name Memory
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Memory
+ */
+exports.Memory = {
+    typeUrl: "/akash.base.v1beta3.Memory",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.quantity !== undefined) {
+            resourcevalue_1.ResourceValue.encode(message.quantity, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            attribute_1.Attribute.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 = createBaseMemory();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.quantity = resourcevalue_1.ResourceValue.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.attributes.push(attribute_1.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_1.ResourceValue.fromPartial(object.quantity) : undefined;
+        message.attributes = object.attributes?.map(e => attribute_1.Attribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMemory();
+        if (object.quantity !== undefined && object.quantity !== null) {
+            message.quantity = resourcevalue_1.ResourceValue.fromAmino(object.quantity);
+        }
+        message.attributes = object.attributes?.map(e => attribute_1.Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.quantity = message.quantity ? resourcevalue_1.ResourceValue.toAmino(message.quantity) : resourcevalue_1.ResourceValue.toAmino(resourcevalue_1.ResourceValue.fromPartial({}));
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? attribute_1.Attribute.toAmino(e) : undefined);
+        }
+        else {
+            obj.attributes = message.attributes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Memory.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Memory.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Memory.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.v1beta3.Memory",
+            value: exports.Memory.encode(message).finish()
+        };
+    }
+};

package/akash/base/v1beta3/resources.d.ts

@@ -0,0 +1,64 @@
+import { CPU, CPUAmino } from "./cpu";
+import { Memory, MemoryAmino } from "./memory";
+import { Storage, StorageAmino } from "./storage";
+import { GPU, GPUAmino } from "./gpu";
+import { Endpoint, EndpointAmino } from "./endpoint";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * 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.v1beta3
+ * @see proto type: akash.base.v1beta3.Resources
+ */
+export interface Resources {
+    id: number;
+    cpu?: CPU;
+    memory?: Memory;
+    storage: Storage[];
+    gpu?: GPU;
+    endpoints: Endpoint[];
+}
+export interface ResourcesProtoMsg {
+    typeUrl: "/akash.base.v1beta3.Resources";
+    value: Uint8Array;
+}
+/**
+ * Resources describes all available resources types for deployment/node etc
+ * if field is nil resource is not present in the given data-structure
+ * @name ResourcesAmino
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Resources
+ */
+export interface ResourcesAmino {
+    id: number;
+    cpu?: CPUAmino;
+    memory?: MemoryAmino;
+    storage?: StorageAmino[];
+    gpu?: GPUAmino;
+    endpoints: EndpointAmino[];
+}
+export interface ResourcesAminoMsg {
+    type: "/akash.base.v1beta3.Resources";
+    value: ResourcesAmino;
+}
+/**
+ * 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.v1beta3
+ * @see proto type: akash.base.v1beta3.Resources
+ */
+export declare const Resources: {
+    typeUrl: string;
+    encode(message: Resources, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Resources;
+    fromPartial(object: DeepPartial<Resources>): Resources;
+    fromAmino(object: ResourcesAmino): Resources;
+    toAmino(message: Resources): ResourcesAmino;
+    fromAminoMsg(object: ResourcesAminoMsg): Resources;
+    fromProtoMsg(message: ResourcesProtoMsg): Resources;
+    toProto(message: Resources): Uint8Array;
+    toProtoMsg(message: Resources): ResourcesProtoMsg;
+};

package/akash/base/v1beta3/resources.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resources = void 0;
+//@ts-nocheck
+const cpu_1 = require("./cpu");
+const memory_1 = require("./memory");
+const storage_1 = require("./storage");
+const gpu_1 = require("./gpu");
+const endpoint_1 = require("./endpoint");
+const binary_1 = require("../../../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.v1beta3
+ * @see proto type: akash.base.v1beta3.Resources
+ */
+exports.Resources = {
+    typeUrl: "/akash.base.v1beta3.Resources",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.id !== 0) {
+            writer.uint32(8).uint32(message.id);
+        }
+        if (message.cpu !== undefined) {
+            cpu_1.CPU.encode(message.cpu, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.memory !== undefined) {
+            memory_1.Memory.encode(message.memory, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.storage) {
+            storage_1.Storage.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.gpu !== undefined) {
+            gpu_1.GPU.encode(message.gpu, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.endpoints) {
+            endpoint_1.Endpoint.encode(v, writer.uint32(50).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 = createBaseResources();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint32();
+                    break;
+                case 2:
+                    message.cpu = cpu_1.CPU.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.memory = memory_1.Memory.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.storage.push(storage_1.Storage.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.gpu = gpu_1.GPU.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.endpoints.push(endpoint_1.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_1.CPU.fromPartial(object.cpu) : undefined;
+        message.memory = object.memory !== undefined && object.memory !== null ? memory_1.Memory.fromPartial(object.memory) : undefined;
+        message.storage = object.storage?.map(e => storage_1.Storage.fromPartial(e)) || [];
+        message.gpu = object.gpu !== undefined && object.gpu !== null ? gpu_1.GPU.fromPartial(object.gpu) : undefined;
+        message.endpoints = object.endpoints?.map(e => endpoint_1.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_1.CPU.fromAmino(object.cpu);
+        }
+        if (object.memory !== undefined && object.memory !== null) {
+            message.memory = memory_1.Memory.fromAmino(object.memory);
+        }
+        message.storage = object.storage?.map(e => storage_1.Storage.fromAmino(e)) || [];
+        if (object.gpu !== undefined && object.gpu !== null) {
+            message.gpu = gpu_1.GPU.fromAmino(object.gpu);
+        }
+        message.endpoints = object.endpoints?.map(e => endpoint_1.Endpoint.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ?? 0;
+        obj.cpu = message.cpu ? cpu_1.CPU.toAmino(message.cpu) : undefined;
+        obj.memory = message.memory ? memory_1.Memory.toAmino(message.memory) : undefined;
+        if (message.storage) {
+            obj.storage = message.storage.map(e => e ? storage_1.Storage.toAmino(e) : undefined);
+        }
+        else {
+            obj.storage = message.storage;
+        }
+        obj.gpu = message.gpu ? gpu_1.GPU.toAmino(message.gpu) : undefined;
+        if (message.endpoints) {
+            obj.endpoints = message.endpoints.map(e => e ? endpoint_1.Endpoint.toAmino(e) : undefined);
+        }
+        else {
+            obj.endpoints = message.endpoints;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Resources.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Resources.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Resources.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.v1beta3.Resources",
+            value: exports.Resources.encode(message).finish()
+        };
+    }
+};

package/akash/base/v1beta3/resourcevalue.d.ts

@@ -0,0 +1,46 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Unit stores cpu, memory and storage metrics
+ * @name ResourceValue
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.ResourceValue
+ */
+export interface ResourceValue {
+    val: Uint8Array;
+}
+export interface ResourceValueProtoMsg {
+    typeUrl: "/akash.base.v1beta3.ResourceValue";
+    value: Uint8Array;
+}
+/**
+ * Unit stores cpu, memory and storage metrics
+ * @name ResourceValueAmino
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.ResourceValue
+ */
+export interface ResourceValueAmino {
+    val?: string;
+}
+export interface ResourceValueAminoMsg {
+    type: "/akash.base.v1beta3.ResourceValue";
+    value: ResourceValueAmino;
+}
+/**
+ * Unit stores cpu, memory and storage metrics
+ * @name ResourceValue
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.ResourceValue
+ */
+export declare const ResourceValue: {
+    typeUrl: string;
+    encode(message: ResourceValue, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResourceValue;
+    fromPartial(object: DeepPartial<ResourceValue>): ResourceValue;
+    fromAmino(object: ResourceValueAmino): ResourceValue;
+    toAmino(message: ResourceValue): ResourceValueAmino;
+    fromAminoMsg(object: ResourceValueAminoMsg): ResourceValue;
+    fromProtoMsg(message: ResourceValueProtoMsg): ResourceValue;
+    toProto(message: ResourceValue): Uint8Array;
+    toProtoMsg(message: ResourceValue): ResourceValueProtoMsg;
+};

package/akash/base/v1beta3/resourcevalue.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceValue = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseResourceValue() {
+    return {
+        val: new Uint8Array()
+    };
+}
+/**
+ * Unit stores cpu, memory and storage metrics
+ * @name ResourceValue
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.ResourceValue
+ */
+exports.ResourceValue = {
+    typeUrl: "/akash.base.v1beta3.ResourceValue",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.val.length !== 0) {
+            writer.uint32(10).bytes(message.val);
+        }
+        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 = 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 = (0, helpers_1.bytesFromBase64)(object.val);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.val = message.val ? (0, helpers_1.base64FromBytes)(message.val) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ResourceValue.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ResourceValue.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ResourceValue.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.v1beta3.ResourceValue",
+            value: exports.ResourceValue.encode(message).finish()
+        };
+    }
+};

package/akash/base/v1beta3/storage.d.ts

@@ -0,0 +1,52 @@
+import { ResourceValue, ResourceValueAmino } from "./resourcevalue";
+import { Attribute, AttributeAmino } from "./attribute";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Storage stores resource quantity and storage attributes
+ * @name Storage
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Storage
+ */
+export interface Storage {
+    name: string;
+    quantity: ResourceValue;
+    attributes: Attribute[];
+}
+export interface StorageProtoMsg {
+    typeUrl: "/akash.base.v1beta3.Storage";
+    value: Uint8Array;
+}
+/**
+ * Storage stores resource quantity and storage attributes
+ * @name StorageAmino
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Storage
+ */
+export interface StorageAmino {
+    name: string;
+    quantity: ResourceValueAmino;
+    attributes?: AttributeAmino[];
+}
+export interface StorageAminoMsg {
+    type: "/akash.base.v1beta3.Storage";
+    value: StorageAmino;
+}
+/**
+ * Storage stores resource quantity and storage attributes
+ * @name Storage
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Storage
+ */
+export declare const Storage: {
+    typeUrl: string;
+    encode(message: Storage, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Storage;
+    fromPartial(object: DeepPartial<Storage>): Storage;
+    fromAmino(object: StorageAmino): Storage;
+    toAmino(message: Storage): StorageAmino;
+    fromAminoMsg(object: StorageAminoMsg): Storage;
+    fromProtoMsg(message: StorageProtoMsg): Storage;
+    toProto(message: Storage): Uint8Array;
+    toProtoMsg(message: Storage): StorageProtoMsg;
+};