@sparkdreamnft/sparkdreamjs 0.0.27 → 0.0.29

package/akash/cert/v1beta3/cert.rpc.msg.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientImpl = exports.MsgClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const cert_1 = require("./cert");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* CreateCertificate defines a method to create new certificate given proper inputs. */
+    createCertificate = async (request) => {
+        const data = cert_1.MsgCreateCertificate.encode(request).finish();
+        const promise = this.rpc.request("akash.cert.v1beta3.Msg", "CreateCertificate", data);
+        return promise.then(data => cert_1.MsgCreateCertificateResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* RevokeCertificate defines a method to revoke the certificate */
+    revokeCertificate = async (request) => {
+        const data = cert_1.MsgRevokeCertificate.encode(request).finish();
+        const promise = this.rpc.request("akash.cert.v1beta3.Msg", "RevokeCertificate", data);
+        return promise.then(data => cert_1.MsgRevokeCertificateResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/akash/cert/v1beta3/genesis.d.ts

@@ -0,0 +1,93 @@
+import { Certificate, CertificateAmino } from "./cert";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * GenesisCertificate defines certificate entry at genesis
+ * @name GenesisCertificate
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisCertificate
+ */
+export interface GenesisCertificate {
+    owner: string;
+    certificate: Certificate;
+}
+export interface GenesisCertificateProtoMsg {
+    typeUrl: "/akash.cert.v1beta3.GenesisCertificate";
+    value: Uint8Array;
+}
+/**
+ * GenesisCertificate defines certificate entry at genesis
+ * @name GenesisCertificateAmino
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisCertificate
+ */
+export interface GenesisCertificateAmino {
+    owner: string;
+    certificate: CertificateAmino;
+}
+export interface GenesisCertificateAminoMsg {
+    type: "/akash.cert.v1beta3.GenesisCertificate";
+    value: GenesisCertificateAmino;
+}
+/**
+ * GenesisState defines the basic genesis state used by cert module
+ * @name GenesisState
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisState
+ */
+export interface GenesisState {
+    certificates: GenesisCertificate[];
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/akash.cert.v1beta3.GenesisState";
+    value: Uint8Array;
+}
+/**
+ * GenesisState defines the basic genesis state used by cert module
+ * @name GenesisStateAmino
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisState
+ */
+export interface GenesisStateAmino {
+    certificates: GenesisCertificateAmino[];
+}
+export interface GenesisStateAminoMsg {
+    type: "/akash.cert.v1beta3.GenesisState";
+    value: GenesisStateAmino;
+}
+/**
+ * GenesisCertificate defines certificate entry at genesis
+ * @name GenesisCertificate
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisCertificate
+ */
+export declare const GenesisCertificate: {
+    typeUrl: string;
+    encode(message: GenesisCertificate, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisCertificate;
+    fromPartial(object: DeepPartial<GenesisCertificate>): GenesisCertificate;
+    fromAmino(object: GenesisCertificateAmino): GenesisCertificate;
+    toAmino(message: GenesisCertificate): GenesisCertificateAmino;
+    fromAminoMsg(object: GenesisCertificateAminoMsg): GenesisCertificate;
+    fromProtoMsg(message: GenesisCertificateProtoMsg): GenesisCertificate;
+    toProto(message: GenesisCertificate): Uint8Array;
+    toProtoMsg(message: GenesisCertificate): GenesisCertificateProtoMsg;
+};
+/**
+ * GenesisState defines the basic genesis state used by cert module
+ * @name GenesisState
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisState
+ */
+export declare const GenesisState: {
+    typeUrl: string;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/akash/cert/v1beta3/genesis.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = exports.GenesisCertificate = void 0;
+//@ts-nocheck
+const cert_1 = require("./cert");
+const binary_1 = require("../../../binary");
+function createBaseGenesisCertificate() {
+    return {
+        owner: "",
+        certificate: cert_1.Certificate.fromPartial({})
+    };
+}
+/**
+ * GenesisCertificate defines certificate entry at genesis
+ * @name GenesisCertificate
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.GenesisCertificate
+ */
+exports.GenesisCertificate = {
+    typeUrl: "/akash.cert.v1beta3.GenesisCertificate",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.certificate !== undefined) {
+            cert_1.Certificate.encode(message.certificate, 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 = createBaseGenesisCertificate();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.certificate = cert_1.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 ? cert_1.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 = cert_1.Certificate.fromAmino(object.certificate);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.certificate = message.certificate ? cert_1.Certificate.toAmino(message.certificate) : cert_1.Certificate.toAmino(cert_1.Certificate.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisCertificate.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisCertificate.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisCertificate.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.GenesisCertificate",
+            value: exports.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
+ */
+exports.GenesisState = {
+    typeUrl: "/akash.cert.v1beta3.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.certificates) {
+            exports.GenesisCertificate.encode(v, writer.uint32(10).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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.certificates.push(exports.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 => exports.GenesisCertificate.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.certificates = object.certificates?.map(e => exports.GenesisCertificate.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.certificates) {
+            obj.certificates = message.certificates.map(e => e ? exports.GenesisCertificate.toAmino(e) : undefined);
+        }
+        else {
+            obj.certificates = message.certificates;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};

package/akash/cert/v1beta3/query.d.ts

@@ -0,0 +1,142 @@
+import { CertificateFilter, CertificateFilterAmino, Certificate, CertificateAmino } from "./cert";
+import { PageRequest, PageRequestAmino, PageResponse, PageResponseAmino } from "../../../cosmos/base/query/v1beta1/pagination";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * CertificateResponse contains a single X509 certificate and its serial number
+ * @name CertificateResponse
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.CertificateResponse
+ */
+export interface CertificateResponse {
+    certificate: Certificate;
+    serial: string;
+}
+export interface CertificateResponseProtoMsg {
+    typeUrl: "/akash.cert.v1beta3.CertificateResponse";
+    value: Uint8Array;
+}
+/**
+ * CertificateResponse contains a single X509 certificate and its serial number
+ * @name CertificateResponseAmino
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.CertificateResponse
+ */
+export interface CertificateResponseAmino {
+    certificate: CertificateAmino;
+    serial: string;
+}
+export interface CertificateResponseAminoMsg {
+    type: "/akash.cert.v1beta3.CertificateResponse";
+    value: CertificateResponseAmino;
+}
+/**
+ * QueryDeploymentsRequest is request type for the Query/Deployments RPC method
+ * @name QueryCertificatesRequest
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesRequest
+ */
+export interface QueryCertificatesRequest {
+    filter: CertificateFilter;
+    pagination?: PageRequest;
+}
+export interface QueryCertificatesRequestProtoMsg {
+    typeUrl: "/akash.cert.v1beta3.QueryCertificatesRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryDeploymentsRequest is request type for the Query/Deployments RPC method
+ * @name QueryCertificatesRequestAmino
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesRequest
+ */
+export interface QueryCertificatesRequestAmino {
+    filter?: CertificateFilterAmino;
+    pagination?: PageRequestAmino;
+}
+export interface QueryCertificatesRequestAminoMsg {
+    type: "/akash.cert.v1beta3.QueryCertificatesRequest";
+    value: QueryCertificatesRequestAmino;
+}
+/**
+ * QueryCertificatesResponse is response type for the Query/Certificates RPC method
+ * @name QueryCertificatesResponse
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesResponse
+ */
+export interface QueryCertificatesResponse {
+    certificates: CertificateResponse[];
+    pagination?: PageResponse;
+}
+export interface QueryCertificatesResponseProtoMsg {
+    typeUrl: "/akash.cert.v1beta3.QueryCertificatesResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryCertificatesResponse is response type for the Query/Certificates RPC method
+ * @name QueryCertificatesResponseAmino
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesResponse
+ */
+export interface QueryCertificatesResponseAmino {
+    certificates?: CertificateResponseAmino[];
+    pagination?: PageResponseAmino;
+}
+export interface QueryCertificatesResponseAminoMsg {
+    type: "/akash.cert.v1beta3.QueryCertificatesResponse";
+    value: QueryCertificatesResponseAmino;
+}
+/**
+ * CertificateResponse contains a single X509 certificate and its serial number
+ * @name CertificateResponse
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.CertificateResponse
+ */
+export declare const CertificateResponse: {
+    typeUrl: string;
+    encode(message: CertificateResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CertificateResponse;
+    fromPartial(object: DeepPartial<CertificateResponse>): CertificateResponse;
+    fromAmino(object: CertificateResponseAmino): CertificateResponse;
+    toAmino(message: CertificateResponse): CertificateResponseAmino;
+    fromAminoMsg(object: CertificateResponseAminoMsg): CertificateResponse;
+    fromProtoMsg(message: CertificateResponseProtoMsg): CertificateResponse;
+    toProto(message: CertificateResponse): Uint8Array;
+    toProtoMsg(message: CertificateResponse): CertificateResponseProtoMsg;
+};
+/**
+ * QueryDeploymentsRequest is request type for the Query/Deployments RPC method
+ * @name QueryCertificatesRequest
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesRequest
+ */
+export declare const QueryCertificatesRequest: {
+    typeUrl: string;
+    encode(message: QueryCertificatesRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCertificatesRequest;
+    fromPartial(object: DeepPartial<QueryCertificatesRequest>): QueryCertificatesRequest;
+    fromAmino(object: QueryCertificatesRequestAmino): QueryCertificatesRequest;
+    toAmino(message: QueryCertificatesRequest): QueryCertificatesRequestAmino;
+    fromAminoMsg(object: QueryCertificatesRequestAminoMsg): QueryCertificatesRequest;
+    fromProtoMsg(message: QueryCertificatesRequestProtoMsg): QueryCertificatesRequest;
+    toProto(message: QueryCertificatesRequest): Uint8Array;
+    toProtoMsg(message: QueryCertificatesRequest): QueryCertificatesRequestProtoMsg;
+};
+/**
+ * QueryCertificatesResponse is response type for the Query/Certificates RPC method
+ * @name QueryCertificatesResponse
+ * @package akash.cert.v1beta3
+ * @see proto type: akash.cert.v1beta3.QueryCertificatesResponse
+ */
+export declare const QueryCertificatesResponse: {
+    typeUrl: string;
+    encode(message: QueryCertificatesResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCertificatesResponse;
+    fromPartial(object: DeepPartial<QueryCertificatesResponse>): QueryCertificatesResponse;
+    fromAmino(object: QueryCertificatesResponseAmino): QueryCertificatesResponse;
+    toAmino(message: QueryCertificatesResponse): QueryCertificatesResponseAmino;
+    fromAminoMsg(object: QueryCertificatesResponseAminoMsg): QueryCertificatesResponse;
+    fromProtoMsg(message: QueryCertificatesResponseProtoMsg): QueryCertificatesResponse;
+    toProto(message: QueryCertificatesResponse): Uint8Array;
+    toProtoMsg(message: QueryCertificatesResponse): QueryCertificatesResponseProtoMsg;
+};

package/akash/cert/v1beta3/query.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryCertificatesResponse = exports.QueryCertificatesRequest = exports.CertificateResponse = void 0;
+//@ts-nocheck
+const cert_1 = require("./cert");
+const pagination_1 = require("../../../cosmos/base/query/v1beta1/pagination");
+const binary_1 = require("../../../binary");
+function createBaseCertificateResponse() {
+    return {
+        certificate: cert_1.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
+ */
+exports.CertificateResponse = {
+    typeUrl: "/akash.cert.v1beta3.CertificateResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.certificate !== undefined) {
+            cert_1.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 binary_1.BinaryReader ? input : new binary_1.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 = cert_1.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 ? cert_1.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 = cert_1.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 ? cert_1.Certificate.toAmino(message.certificate) : cert_1.Certificate.toAmino(cert_1.Certificate.fromPartial({}));
+        obj.serial = message.serial ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.CertificateResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.CertificateResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.CertificateResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.CertificateResponse",
+            value: exports.CertificateResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCertificatesRequest() {
+    return {
+        filter: cert_1.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
+ */
+exports.QueryCertificatesRequest = {
+    typeUrl: "/akash.cert.v1beta3.QueryCertificatesRequest",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.filter !== undefined) {
+            cert_1.CertificateFilter.encode(message.filter, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            pagination_1.PageRequest.encode(message.pagination, 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 = createBaseQueryCertificatesRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.filter = cert_1.CertificateFilter.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.pagination = pagination_1.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 ? cert_1.CertificateFilter.fromPartial(object.filter) : undefined;
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? pagination_1.PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCertificatesRequest();
+        if (object.filter !== undefined && object.filter !== null) {
+            message.filter = cert_1.CertificateFilter.fromAmino(object.filter);
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = pagination_1.PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.filter = message.filter ? cert_1.CertificateFilter.toAmino(message.filter) : undefined;
+        obj.pagination = message.pagination ? pagination_1.PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryCertificatesRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryCertificatesRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryCertificatesRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.QueryCertificatesRequest",
+            value: exports.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
+ */
+exports.QueryCertificatesResponse = {
+    typeUrl: "/akash.cert.v1beta3.QueryCertificatesResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.certificates) {
+            exports.CertificateResponse.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            pagination_1.PageResponse.encode(message.pagination, 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 = createBaseQueryCertificatesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.certificates.push(exports.CertificateResponse.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = pagination_1.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 => exports.CertificateResponse.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? pagination_1.PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCertificatesResponse();
+        message.certificates = object.certificates?.map(e => exports.CertificateResponse.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = pagination_1.PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.certificates) {
+            obj.certificates = message.certificates.map(e => e ? exports.CertificateResponse.toAmino(e) : undefined);
+        }
+        else {
+            obj.certificates = message.certificates;
+        }
+        obj.pagination = message.pagination ? pagination_1.PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryCertificatesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryCertificatesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryCertificatesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.cert.v1beta3.QueryCertificatesResponse",
+            value: exports.QueryCertificatesResponse.encode(message).finish()
+        };
+    }
+};

package/akash/cert/v1beta3/query.lcd.d.ts

@@ -0,0 +1,9 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryCertificatesRequest, QueryCertificatesResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    certificates: (params: QueryCertificatesRequest) => Promise<QueryCertificatesResponse>;
+}