@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/akash/base/resources/v1beta4/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.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.ResourceValue
+ */
+export interface ResourceValue {
+    val: Uint8Array;
+}
+export interface ResourceValueProtoMsg {
+    typeUrl: "/akash.base.resources.v1beta4.ResourceValue";
+    value: Uint8Array;
+}
+/**
+ * Unit stores cpu, memory and storage metrics.
+ * @name ResourceValueAmino
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.ResourceValue
+ */
+export interface ResourceValueAmino {
+    val?: string;
+}
+export interface ResourceValueAminoMsg {
+    type: "/akash.base.resources.v1beta4.ResourceValue";
+    value: ResourceValueAmino;
+}
+/**
+ * Unit stores cpu, memory and storage metrics.
+ * @name ResourceValue
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.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/resources/v1beta4/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.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.ResourceValue
+ */
+exports.ResourceValue = {
+    typeUrl: "/akash.base.resources.v1beta4.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.resources.v1beta4.ResourceValue",
+            value: exports.ResourceValue.encode(message).finish()
+        };
+    }
+};

package/akash/base/resources/v1beta4/storage.d.ts

@@ -0,0 +1,74 @@
+import { ResourceValue, ResourceValueAmino } from "./resourcevalue";
+import { Attribute, AttributeAmino } from "../../attributes/v1/attribute";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * Storage stores resource quantity and storage attributes.
+ * @name Storage
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Storage
+ */
+export interface Storage {
+    /**
+     * Name holds an arbitrary name for the storage resource.
+     */
+    name: string;
+    /**
+     * Quantity of storage available, which represents the amount of memory in bytes.
+     * This field is required and must be a non-negative integer.
+     */
+    quantity: ResourceValue;
+    /**
+     * Attributes that describe the storage.
+     * This field is required and must be a list of Attribute key-values.
+     */
+    attributes: Attribute[];
+}
+export interface StorageProtoMsg {
+    typeUrl: "/akash.base.resources.v1beta4.Storage";
+    value: Uint8Array;
+}
+/**
+ * Storage stores resource quantity and storage attributes.
+ * @name StorageAmino
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Storage
+ */
+export interface StorageAmino {
+    /**
+     * Name holds an arbitrary name for the storage resource.
+     */
+    name: string;
+    /**
+     * Quantity of storage available, which represents the amount of memory in bytes.
+     * This field is required and must be a non-negative integer.
+     */
+    quantity: ResourceValueAmino;
+    /**
+     * Attributes that describe the storage.
+     * This field is required and must be a list of Attribute key-values.
+     */
+    attributes?: AttributeAmino[];
+}
+export interface StorageAminoMsg {
+    type: "/akash.base.resources.v1beta4.Storage";
+    value: StorageAmino;
+}
+/**
+ * Storage stores resource quantity and storage attributes.
+ * @name Storage
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.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;
+};

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+//@ts-nocheck
+const resourcevalue_1 = require("./resourcevalue");
+const attribute_1 = require("../../attributes/v1/attribute");
+const binary_1 = require("../../../../binary");
+function createBaseStorage() {
+    return {
+        name: "",
+        quantity: resourcevalue_1.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
+ */
+exports.Storage = {
+    typeUrl: "/akash.base.resources.v1beta4.Storage",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.quantity !== undefined) {
+            resourcevalue_1.ResourceValue.encode(message.quantity, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            attribute_1.Attribute.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStorage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.quantity = resourcevalue_1.ResourceValue.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.attributes.push(attribute_1.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_1.ResourceValue.fromPartial(object.quantity) : undefined;
+        message.attributes = object.attributes?.map(e => attribute_1.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_1.ResourceValue.fromAmino(object.quantity);
+        }
+        message.attributes = object.attributes?.map(e => attribute_1.Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name ?? "";
+        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.Storage.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Storage.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Storage.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.resources.v1beta4.Storage",
+            value: exports.Storage.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,173 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Attribute represents key value pair
+ * @name Attribute
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Attribute
+ */
+export interface Attribute {
+    key: string;
+    value: string;
+}
+export interface AttributeProtoMsg {
+    typeUrl: "/akash.base.v1beta3.Attribute";
+    value: Uint8Array;
+}
+/**
+ * Attribute represents key value pair
+ * @name AttributeAmino
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Attribute
+ */
+export interface AttributeAmino {
+    key?: string;
+    value?: string;
+}
+export interface AttributeAminoMsg {
+    type: "/akash.base.v1beta3.Attribute";
+    value: AttributeAmino;
+}
+/**
+ * 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 interface SignedBy {
+    /**
+     * all_of all keys in this list must have signed attributes
+     */
+    allOf: string[];
+    /**
+     * any_of at least of of the keys from the list must have signed attributes
+     */
+    anyOf: string[];
+}
+export interface SignedByProtoMsg {
+    typeUrl: "/akash.base.v1beta3.SignedBy";
+    value: Uint8Array;
+}
+/**
+ * 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 SignedByAmino
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.SignedBy
+ */
+export interface SignedByAmino {
+    /**
+     * all_of all keys in this list must have signed attributes
+     */
+    all_of: string[];
+    /**
+     * any_of at least of of the keys from the list must have signed attributes
+     */
+    any_of: string[];
+}
+export interface SignedByAminoMsg {
+    type: "/akash.base.v1beta3.SignedBy";
+    value: SignedByAmino;
+}
+/**
+ * PlacementRequirements
+ * @name PlacementRequirements
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.PlacementRequirements
+ */
+export interface PlacementRequirements {
+    /**
+     * SignedBy list of keys that tenants expect to have signatures from
+     */
+    signedBy: SignedBy;
+    /**
+     * Attribute list of attributes tenant expects from the provider
+     */
+    attributes: Attribute[];
+}
+export interface PlacementRequirementsProtoMsg {
+    typeUrl: "/akash.base.v1beta3.PlacementRequirements";
+    value: Uint8Array;
+}
+/**
+ * PlacementRequirements
+ * @name PlacementRequirementsAmino
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.PlacementRequirements
+ */
+export interface PlacementRequirementsAmino {
+    /**
+     * SignedBy list of keys that tenants expect to have signatures from
+     */
+    signed_by: SignedByAmino;
+    /**
+     * Attribute list of attributes tenant expects from the provider
+     */
+    attributes: AttributeAmino[];
+}
+export interface PlacementRequirementsAminoMsg {
+    type: "/akash.base.v1beta3.PlacementRequirements";
+    value: PlacementRequirementsAmino;
+}
+/**
+ * Attribute represents key value pair
+ * @name Attribute
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.Attribute
+ */
+export declare const Attribute: {
+    typeUrl: string;
+    encode(message: Attribute, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Attribute;
+    fromPartial(object: DeepPartial<Attribute>): Attribute;
+    fromAmino(object: AttributeAmino): Attribute;
+    toAmino(message: Attribute): AttributeAmino;
+    fromAminoMsg(object: AttributeAminoMsg): Attribute;
+    fromProtoMsg(message: AttributeProtoMsg): Attribute;
+    toProto(message: Attribute): Uint8Array;
+    toProtoMsg(message: Attribute): AttributeProtoMsg;
+};
+/**
+ * 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 declare const SignedBy: {
+    typeUrl: string;
+    encode(message: SignedBy, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SignedBy;
+    fromPartial(object: DeepPartial<SignedBy>): SignedBy;
+    fromAmino(object: SignedByAmino): SignedBy;
+    toAmino(message: SignedBy): SignedByAmino;
+    fromAminoMsg(object: SignedByAminoMsg): SignedBy;
+    fromProtoMsg(message: SignedByProtoMsg): SignedBy;
+    toProto(message: SignedBy): Uint8Array;
+    toProtoMsg(message: SignedBy): SignedByProtoMsg;
+};
+/**
+ * PlacementRequirements
+ * @name PlacementRequirements
+ * @package akash.base.v1beta3
+ * @see proto type: akash.base.v1beta3.PlacementRequirements
+ */
+export declare const PlacementRequirements: {
+    typeUrl: string;
+    encode(message: PlacementRequirements, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PlacementRequirements;
+    fromPartial(object: DeepPartial<PlacementRequirements>): PlacementRequirements;
+    fromAmino(object: PlacementRequirementsAmino): PlacementRequirements;
+    toAmino(message: PlacementRequirements): PlacementRequirementsAmino;
+    fromAminoMsg(object: PlacementRequirementsAminoMsg): PlacementRequirements;
+    fromProtoMsg(message: PlacementRequirementsProtoMsg): PlacementRequirements;
+    toProto(message: PlacementRequirements): Uint8Array;
+    toProtoMsg(message: PlacementRequirements): PlacementRequirementsProtoMsg;
+};