@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/esm/akash/audit/v1beta3/query.rpc.Query.js

@@ -0,0 +1,61 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryAllProvidersAttributesRequest, QueryProvidersResponse, QueryProviderAttributesRequest, QueryProviderAuditorRequest, QueryAuditorAttributesRequest } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* AllProvidersAttributes queries all providers
+     buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     buf:lint:ignore RPC_RESPONSE_STANDARD_NAME */
+    allProvidersAttributes = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QueryAllProvidersAttributesRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.audit.v1beta3.Query", "AllProvidersAttributes", data);
+        return promise.then(data => QueryProvidersResponse.decode(new BinaryReader(data)));
+    };
+    /* ProviderAttributes queries all provider signed attributes
+     buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     buf:lint:ignore RPC_RESPONSE_STANDARD_NAME */
+    providerAttributes = async (request) => {
+        const data = QueryProviderAttributesRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.audit.v1beta3.Query", "ProviderAttributes", data);
+        return promise.then(data => QueryProvidersResponse.decode(new BinaryReader(data)));
+    };
+    /* ProviderAuditorAttributes queries provider signed attributes by specific auditor
+     buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     buf:lint:ignore RPC_RESPONSE_STANDARD_NAME */
+    providerAuditorAttributes = async (request) => {
+        const data = QueryProviderAuditorRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.audit.v1beta3.Query", "ProviderAuditorAttributes", data);
+        return promise.then(data => QueryProvidersResponse.decode(new BinaryReader(data)));
+    };
+    /* AuditorAttributes queries all providers signed by this auditor
+     buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     buf:lint:ignore RPC_RESPONSE_STANDARD_NAME */
+    auditorAttributes = async (request) => {
+        const data = QueryAuditorAttributesRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.audit.v1beta3.Query", "AuditorAttributes", data);
+        return promise.then(data => QueryProvidersResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        allProvidersAttributes(request) {
+            return queryService.allProvidersAttributes(request);
+        },
+        providerAttributes(request) {
+            return queryService.providerAttributes(request);
+        },
+        providerAuditorAttributes(request) {
+            return queryService.providerAuditorAttributes(request);
+        },
+        auditorAttributes(request) {
+            return queryService.auditorAttributes(request);
+        }
+    };
+};

package/esm/akash/base/attributes/v1/attribute.js

@@ -0,0 +1,257 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseAttribute() {
+    return {
+        key: "",
+        value: ""
+    };
+}
+/**
+ * Attribute represents an arbitrary attribute key-value pair.
+ * @name Attribute
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.Attribute
+ */
+export const Attribute = {
+    typeUrl: "/akash.base.attributes.v1.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.attributes.v1.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.
+ * @name SignedBy
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.SignedBy
+ */
+export const SignedBy = {
+    typeUrl: "/akash.base.attributes.v1.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.attributes.v1.SignedBy",
+            value: SignedBy.encode(message).finish()
+        };
+    }
+};
+function createBasePlacementRequirements() {
+    return {
+        signedBy: SignedBy.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * PlacementRequirements represents the requirements for a provider placement on the network.
+ * It is used to specify the characteristics and constraints of a provider that can be used to satisfy a deployment request.
+ * @name PlacementRequirements
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.PlacementRequirements
+ */
+export const PlacementRequirements = {
+    typeUrl: "/akash.base.attributes.v1.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.attributes.v1.PlacementRequirements",
+            value: PlacementRequirements.encode(message).finish()
+        };
+    }
+};

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

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

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

@@ -0,0 +1,125 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** Kind describes how the endpoint is implemented when the lease is deployed. */
+export var Endpoint_Kind;
+(function (Endpoint_Kind) {
+    /** SHARED_HTTP - Describes an endpoint that becomes a Kubernetes Ingress. */
+    Endpoint_Kind[Endpoint_Kind["SHARED_HTTP"] = 0] = "SHARED_HTTP";
+    /** RANDOM_PORT - Describes an endpoint that becomes a Kubernetes NodePort. */
+    Endpoint_Kind[Endpoint_Kind["RANDOM_PORT"] = 1] = "RANDOM_PORT";
+    /** LEASED_IP - Describes an endpoint that becomes a leased IP. */
+    Endpoint_Kind[Endpoint_Kind["LEASED_IP"] = 2] = "LEASED_IP";
+    Endpoint_Kind[Endpoint_Kind["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Endpoint_Kind || (Endpoint_Kind = {}));
+export const Endpoint_KindAmino = Endpoint_Kind;
+export function endpoint_KindFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SHARED_HTTP":
+            return Endpoint_Kind.SHARED_HTTP;
+        case 1:
+        case "RANDOM_PORT":
+            return Endpoint_Kind.RANDOM_PORT;
+        case 2:
+        case "LEASED_IP":
+            return Endpoint_Kind.LEASED_IP;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Endpoint_Kind.UNRECOGNIZED;
+    }
+}
+export function endpoint_KindToJSON(object) {
+    switch (object) {
+        case Endpoint_Kind.SHARED_HTTP:
+            return "SHARED_HTTP";
+        case Endpoint_Kind.RANDOM_PORT:
+            return "RANDOM_PORT";
+        case Endpoint_Kind.LEASED_IP:
+            return "LEASED_IP";
+        case Endpoint_Kind.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseEndpoint() {
+    return {
+        kind: 0,
+        sequenceNumber: 0
+    };
+}
+/**
+ * Endpoint describes a publicly accessible IP service.
+ * @name Endpoint
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Endpoint
+ */
+export const Endpoint = {
+    typeUrl: "/akash.base.resources.v1beta4.Endpoint",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.kind !== 0) {
+            writer.uint32(8).int32(message.kind);
+        }
+        if (message.sequenceNumber !== 0) {
+            writer.uint32(16).uint32(message.sequenceNumber);
+        }
+        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 = createBaseEndpoint();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.kind = reader.int32();
+                    break;
+                case 2:
+                    message.sequenceNumber = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEndpoint();
+        message.kind = object.kind ?? 0;
+        message.sequenceNumber = object.sequenceNumber ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEndpoint();
+        if (object.kind !== undefined && object.kind !== null) {
+            message.kind = object.kind;
+        }
+        if (object.sequence_number !== undefined && object.sequence_number !== null) {
+            message.sequenceNumber = object.sequence_number;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.kind = message.kind === 0 ? undefined : message.kind;
+        obj.sequence_number = message.sequenceNumber ?? 0;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Endpoint.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Endpoint.decode(message.value);
+    },
+    toProto(message) {
+        return Endpoint.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.resources.v1beta4.Endpoint",
+            value: Endpoint.encode(message).finish()
+        };
+    }
+};

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

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