@sparkdreamnft/sparkdreamjs 0.0.27 → 0.0.29

package/esm/akash/cert/v1beta3/genesis.js

@@ -0,0 +1,156 @@
+//@ts-nocheck
+import { Certificate } from "./cert";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisCertificate() {
+    return {
+        owner: "",
+        certificate: Certificate.fromPartial({})
+    };
+}
+/**
+ * GenesisCertificate defines certificate entry at genesis
+ * @name GenesisCertificate
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisCertificate
+ */
+export const GenesisCertificate = {
+    typeUrl: "/akash.cert.v1beta3.GenesisCertificate",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.certificate !== undefined) {
+            Certificate.encode(message.certificate, 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 = createBaseGenesisCertificate();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.certificate = Certificate.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisCertificate();
+        message.owner = object.owner ?? "";
+        message.certificate = object.certificate !== undefined && object.certificate !== null ? Certificate.fromPartial(object.certificate) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisCertificate();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.certificate !== undefined && object.certificate !== null) {
+            message.certificate = Certificate.fromAmino(object.certificate);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.certificate = message.certificate ? Certificate.toAmino(message.certificate) : Certificate.toAmino(Certificate.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisCertificate.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisCertificate.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisCertificate.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.GenesisCertificate",
+            value: GenesisCertificate.encode(message).finish()
+        };
+    }
+};
+function createBaseGenesisState() {
+    return {
+        certificates: []
+    };
+}
+/**
+ * GenesisState defines the basic genesis state used by cert module
+ * @name GenesisState
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/akash.cert.v1beta3.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.certificates) {
+            GenesisCertificate.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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.certificates.push(GenesisCertificate.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.certificates = object.certificates?.map(e => GenesisCertificate.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.certificates = object.certificates?.map(e => GenesisCertificate.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.certificates) {
+            obj.certificates = message.certificates.map(e => e ? GenesisCertificate.toAmino(e) : undefined);
+        }
+        else {
+            obj.certificates = message.certificates;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};

package/esm/akash/cert/v1beta3/query.js

@@ -0,0 +1,250 @@
+//@ts-nocheck
+import { CertificateFilter, Certificate } from "./cert";
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseCertificateResponse() {
+    return {
+        certificate: Certificate.fromPartial({}),
+        serial: ""
+    };
+}
+/**
+ * CertificateResponse contains a single X509 certificate and its serial number
+ * @name CertificateResponse
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.CertificateResponse
+ */
+export const CertificateResponse = {
+    typeUrl: "/akash.cert.v1beta3.CertificateResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.certificate !== undefined) {
+            Certificate.encode(message.certificate, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.serial !== "") {
+            writer.uint32(18).string(message.serial);
+        }
+        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 = createBaseCertificateResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.certificate = Certificate.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.serial = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCertificateResponse();
+        message.certificate = object.certificate !== undefined && object.certificate !== null ? Certificate.fromPartial(object.certificate) : undefined;
+        message.serial = object.serial ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCertificateResponse();
+        if (object.certificate !== undefined && object.certificate !== null) {
+            message.certificate = Certificate.fromAmino(object.certificate);
+        }
+        if (object.serial !== undefined && object.serial !== null) {
+            message.serial = object.serial;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.certificate = message.certificate ? Certificate.toAmino(message.certificate) : Certificate.toAmino(Certificate.fromPartial({}));
+        obj.serial = message.serial ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CertificateResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return CertificateResponse.decode(message.value);
+    },
+    toProto(message) {
+        return CertificateResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.CertificateResponse",
+            value: CertificateResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCertificatesRequest() {
+    return {
+        filter: CertificateFilter.fromPartial({}),
+        pagination: undefined
+    };
+}
+/**
+ * QueryDeploymentsRequest is request type for the Query/Deployments RPC method
+ * @name QueryCertificatesRequest
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesRequest
+ */
+export const QueryCertificatesRequest = {
+    typeUrl: "/akash.cert.v1beta3.QueryCertificatesRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.filter !== undefined) {
+            CertificateFilter.encode(message.filter, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, 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 = createBaseQueryCertificatesRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.filter = CertificateFilter.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCertificatesRequest();
+        message.filter = object.filter !== undefined && object.filter !== null ? CertificateFilter.fromPartial(object.filter) : undefined;
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCertificatesRequest();
+        if (object.filter !== undefined && object.filter !== null) {
+            message.filter = CertificateFilter.fromAmino(object.filter);
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.filter = message.filter ? CertificateFilter.toAmino(message.filter) : undefined;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCertificatesRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCertificatesRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCertificatesRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.QueryCertificatesRequest",
+            value: QueryCertificatesRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCertificatesResponse() {
+    return {
+        certificates: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryCertificatesResponse is response type for the Query/Certificates RPC method
+ * @name QueryCertificatesResponse
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesResponse
+ */
+export const QueryCertificatesResponse = {
+    typeUrl: "/akash.cert.v1beta3.QueryCertificatesResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.certificates) {
+            CertificateResponse.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, 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 = createBaseQueryCertificatesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.certificates.push(CertificateResponse.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCertificatesResponse();
+        message.certificates = object.certificates?.map(e => CertificateResponse.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCertificatesResponse();
+        message.certificates = object.certificates?.map(e => CertificateResponse.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.certificates) {
+            obj.certificates = message.certificates.map(e => e ? CertificateResponse.toAmino(e) : undefined);
+        }
+        else {
+            obj.certificates = message.certificates;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCertificatesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCertificatesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCertificatesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.QueryCertificatesResponse",
+            value: QueryCertificatesResponse.encode(message).finish()
+        };
+    }
+};

package/esm/akash/cert/v1beta3/query.lcd.js

@@ -0,0 +1,22 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Certificates queries certificates */
+    certificates = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.filter !== "undefined") {
+            options.params.filter = params.filter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `akash/cert/v1beta3/certificates/list`;
+        return await this.req.get(endpoint, options);
+    };
+}

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

@@ -0,0 +1,24 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryCertificatesRequest, QueryCertificatesResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Certificates queries certificates */
+    certificates = async (request) => {
+        const data = QueryCertificatesRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.cert.v1beta3.Query", "Certificates", data);
+        return promise.then(data => QueryCertificatesResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        certificates(request) {
+            return queryService.certificates(request);
+        }
+    };
+};

package/esm/akash/client.js

@@ -0,0 +1,59 @@
+//@ts-nocheck
+import { Registry } from "@cosmjs/proto-signing";
+import { defaultRegistryTypes, AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import * as akashAuditV1ServiceRegistry from "./audit/v1/service.registry";
+import * as akashAuditV1beta3AuditRegistry from "./audit/v1beta3/audit.registry";
+import * as akashCertV1ServiceRegistry from "./cert/v1/service.registry";
+import * as akashCertV1beta3CertRegistry from "./cert/v1beta3/cert.registry";
+import * as akashDeploymentV1beta3ServiceRegistry from "./deployment/v1beta3/service.registry";
+import * as akashDeploymentV1beta4ServiceRegistry from "./deployment/v1beta4/service.registry";
+import * as akashMarketV1beta4ServiceRegistry from "./market/v1beta4/service.registry";
+import * as akashMarketV1beta5ServiceRegistry from "./market/v1beta5/service.registry";
+import * as akashProviderV1beta3ProviderRegistry from "./provider/v1beta3/provider.registry";
+import * as akashProviderV1beta4ServiceRegistry from "./provider/v1beta4/service.registry";
+import * as akashTakeV1ServiceRegistry from "./take/v1/service.registry";
+import * as akashAuditV1ServiceAmino from "./audit/v1/service.amino";
+import * as akashAuditV1beta3AuditAmino from "./audit/v1beta3/audit.amino";
+import * as akashCertV1ServiceAmino from "./cert/v1/service.amino";
+import * as akashCertV1beta3CertAmino from "./cert/v1beta3/cert.amino";
+import * as akashDeploymentV1beta3ServiceAmino from "./deployment/v1beta3/service.amino";
+import * as akashDeploymentV1beta4ServiceAmino from "./deployment/v1beta4/service.amino";
+import * as akashMarketV1beta4ServiceAmino from "./market/v1beta4/service.amino";
+import * as akashMarketV1beta5ServiceAmino from "./market/v1beta5/service.amino";
+import * as akashProviderV1beta3ProviderAmino from "./provider/v1beta3/provider.amino";
+import * as akashProviderV1beta4ServiceAmino from "./provider/v1beta4/service.amino";
+import * as akashTakeV1ServiceAmino from "./take/v1/service.amino";
+export const akashAminoConverters = {
+    ...akashAuditV1ServiceAmino.AminoConverter,
+    ...akashAuditV1beta3AuditAmino.AminoConverter,
+    ...akashCertV1ServiceAmino.AminoConverter,
+    ...akashCertV1beta3CertAmino.AminoConverter,
+    ...akashDeploymentV1beta3ServiceAmino.AminoConverter,
+    ...akashDeploymentV1beta4ServiceAmino.AminoConverter,
+    ...akashMarketV1beta4ServiceAmino.AminoConverter,
+    ...akashMarketV1beta5ServiceAmino.AminoConverter,
+    ...akashProviderV1beta3ProviderAmino.AminoConverter,
+    ...akashProviderV1beta4ServiceAmino.AminoConverter,
+    ...akashTakeV1ServiceAmino.AminoConverter
+};
+export const akashProtoRegistry = [...akashAuditV1ServiceRegistry.registry, ...akashAuditV1beta3AuditRegistry.registry, ...akashCertV1ServiceRegistry.registry, ...akashCertV1beta3CertRegistry.registry, ...akashDeploymentV1beta3ServiceRegistry.registry, ...akashDeploymentV1beta4ServiceRegistry.registry, ...akashMarketV1beta4ServiceRegistry.registry, ...akashMarketV1beta5ServiceRegistry.registry, ...akashProviderV1beta3ProviderRegistry.registry, ...akashProviderV1beta4ServiceRegistry.registry, ...akashTakeV1ServiceRegistry.registry];
+export const getSigningAkashClientOptions = ({ defaultTypes = defaultRegistryTypes } = {}) => {
+    const registry = new Registry([...defaultTypes, ...akashProtoRegistry]);
+    const aminoTypes = new AminoTypes({
+        ...akashAminoConverters
+    });
+    return {
+        registry,
+        aminoTypes
+    };
+};
+export const getSigningAkashClient = async ({ rpcEndpoint, signer, defaultTypes = defaultRegistryTypes }) => {
+    const { registry, aminoTypes } = getSigningAkashClientOptions({
+        defaultTypes
+    });
+    const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+        registry: registry,
+        aminoTypes
+    });
+    return client;
+};

package/esm/akash/deployment/v1/authz.js

@@ -0,0 +1,73 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseDepositAuthorization() {
+    return {
+        spendLimit: Coin.fromPartial({})
+    };
+}
+/**
+ * DepositAuthorization allows the grantee to deposit up to spend_limit coins from
+ * the granter's account for a deployment.
+ * @name DepositAuthorization
+ * @package akash.deployment.v1
+ * @see proto type: akash.deployment.v1.DepositAuthorization
+ */
+export const DepositAuthorization = {
+    typeUrl: "/akash.deployment.v1.DepositAuthorization",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.spendLimit !== undefined) {
+            Coin.encode(message.spendLimit, 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 = createBaseDepositAuthorization();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.spendLimit = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDepositAuthorization();
+        message.spendLimit = object.spendLimit !== undefined && object.spendLimit !== null ? Coin.fromPartial(object.spendLimit) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDepositAuthorization();
+        if (object.spend_limit !== undefined && object.spend_limit !== null) {
+            message.spendLimit = Coin.fromAmino(object.spend_limit);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.spend_limit = message.spendLimit ? Coin.toAmino(message.spendLimit) : Coin.toAmino(Coin.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DepositAuthorization.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DepositAuthorization.decode(message.value);
+    },
+    toProto(message) {
+        return DepositAuthorization.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.deployment.v1.DepositAuthorization",
+            value: DepositAuthorization.encode(message).finish()
+        };
+    }
+};