@sparkdreamnft/sparkdreamjs 0.0.42 → 0.0.44

package/sparkdream/rpc.query.d.ts

@@ -197,6 +197,29 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
         };
     };
     sparkdream: {
+        artifact: {
+            v1: {
+                params(request?: import("./artifact/v1/query").QueryParamsRequest): Promise<import("./artifact/v1/query").QueryParamsResponse>;
+                class(request: import("./artifact/v1/query").QueryClassRequest): Promise<import("./artifact/v1/query").QueryClassResponse>;
+                classes(request?: import("./artifact/v1/query").QueryClassesRequest): Promise<import("./artifact/v1/query").QueryClassesResponse>;
+                classesByOwner(request: import("./artifact/v1/query").QueryClassesByOwnerRequest): Promise<import("./artifact/v1/query").QueryClassesByOwnerResponse>;
+                token(request: import("./artifact/v1/query").QueryTokenRequest): Promise<import("./artifact/v1/query").QueryTokenResponse>;
+                tokens(request: import("./artifact/v1/query").QueryTokensRequest): Promise<import("./artifact/v1/query").QueryTokensResponse>;
+                tokensByOwner(request: import("./artifact/v1/query").QueryTokensByOwnerRequest): Promise<import("./artifact/v1/query").QueryTokensByOwnerResponse>;
+                owner(request: import("./artifact/v1/query").QueryOwnerRequest): Promise<import("./artifact/v1/query").QueryOwnerResponse>;
+                supply(request: import("./artifact/v1/query").QuerySupplyRequest): Promise<import("./artifact/v1/query").QuerySupplyResponse>;
+                listing(request: import("./artifact/v1/query").QueryListingRequest): Promise<import("./artifact/v1/query").QueryListingResponse>;
+                listings(request: import("./artifact/v1/query").QueryListingsRequest): Promise<import("./artifact/v1/query").QueryListingsResponse>;
+                listingsBySeller(request: import("./artifact/v1/query").QueryListingsBySellerRequest): Promise<import("./artifact/v1/query").QueryListingsBySellerResponse>;
+                inbox(request: import("./artifact/v1/query").QueryInboxRequest): Promise<import("./artifact/v1/query").QueryInboxResponse>;
+                outbox(request: import("./artifact/v1/query").QueryOutboxRequest): Promise<import("./artifact/v1/query").QueryOutboxResponse>;
+                receivePolicy(request: import("./artifact/v1/query").QueryReceivePolicyRequest): Promise<import("./artifact/v1/query").QueryReceivePolicyResponse>;
+                pendingClassOwner(request: import("./artifact/v1/query").QueryPendingClassOwnerRequest): Promise<import("./artifact/v1/query").QueryPendingClassOwnerResponse>;
+                hideRecord(request: import("./artifact/v1/query").QueryHideRecordRequest): Promise<import("./artifact/v1/query").QueryHideRecordResponse>;
+                hideRecordsByTarget(request: import("./artifact/v1/query").QueryHideRecordsByTargetRequest): Promise<import("./artifact/v1/query").QueryHideRecordsByTargetResponse>;
+                publicMintQuote(request: import("./artifact/v1/query").QueryPublicMintQuoteRequest): Promise<import("./artifact/v1/query").QueryPublicMintQuoteResponse>;
+            };
+        };
         blog: {
             v1: {
                 params(request?: import("./blog/v1/query").QueryParamsRequest): Promise<import("./blog/v1/query").QueryParamsResponse>;
@@ -211,6 +234,8 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
                 listReactionsByCreator(request: import("./blog/v1/query").QueryListReactionsByCreatorRequest): Promise<import("./blog/v1/query").QueryListReactionsByCreatorResponse>;
                 listExpiringContent(request: import("./blog/v1/query").QueryListExpiringContentRequest): Promise<import("./blog/v1/query").QueryListExpiringContentResponse>;
                 listPostsByTag(request: import("./blog/v1/query").QueryListPostsByTagRequest): Promise<import("./blog/v1/query").QueryListPostsByTagResponse>;
+                postBody(request: import("./blog/v1/query").QueryPostBodyRequest): Promise<import("./blog/v1/query").QueryPostBodyResponse>;
+                replyBody(request: import("./blog/v1/query").QueryReplyBodyRequest): Promise<import("./blog/v1/query").QueryReplyBodyResponse>;
             };
         };
         collect: {
@@ -288,6 +313,7 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
                 operatorRewardPool(request?: import("./federation/v1/query").QueryOperatorRewardPoolRequest): Promise<import("./federation/v1/query").QueryOperatorRewardPoolResponse>;
                 getVerificationRecord(request: import("./federation/v1/query").QueryGetVerificationRecordRequest): Promise<import("./federation/v1/query").QueryGetVerificationRecordResponse>;
                 getEscalatedChallenge(request: import("./federation/v1/query").QueryGetEscalatedChallengeRequest): Promise<import("./federation/v1/query").QueryGetEscalatedChallengeResponse>;
+                federatedContentBody(request: import("./federation/v1/query").QueryFederatedContentBodyRequest): Promise<import("./federation/v1/query").QueryFederatedContentBodyResponse>;
             };
         };
         forum: {
@@ -341,6 +367,7 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
                 getPostConvictionStake(request: import("./forum/v1/query").QueryGetPostConvictionStakeRequest): Promise<import("./forum/v1/query").QueryGetPostConvictionStakeResponse>;
                 postConvictionStakesByStaker(request: import("./forum/v1/query").QueryPostConvictionStakesByStakerRequest): Promise<import("./forum/v1/query").QueryPostConvictionStakesByStakerResponse>;
                 postConvictionStakesByPost(request: import("./forum/v1/query").QueryPostConvictionStakesByPostRequest): Promise<import("./forum/v1/query").QueryPostConvictionStakesByPostResponse>;
+                postContent(request: import("./forum/v1/query").QueryPostContentRequest): Promise<import("./forum/v1/query").QueryPostContentResponse>;
             };
         };
         futarchy: {
@@ -462,6 +489,8 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
                 reviewBounty(request: import("./rep/v1/query").QueryReviewBountyRequest): Promise<import("./rep/v1/query").QueryReviewBountyResponse>;
                 escalatedReviews(request?: import("./rep/v1/query").QueryEscalatedReviewsRequest): Promise<import("./rep/v1/query").QueryEscalatedReviewsResponse>;
                 roleRewardPools(request?: import("./rep/v1/query").QueryRoleRewardPoolsRequest): Promise<import("./rep/v1/query").QueryRoleRewardPoolsResponse>;
+                initiativeBounty(request: import("./rep/v1/query").QueryInitiativeBountyRequest): Promise<import("./rep/v1/query").QueryInitiativeBountyResponse>;
+                trustTree(request?: import("./rep/v1/query").QueryTrustTreeRequest): Promise<import("./rep/v1/query").QueryTrustTreeResponse>;
             };
         };
         reveal: {
@@ -563,6 +592,8 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
                 report(request: import("./service/v1/query").QueryReportRequest): Promise<import("./service/v1/query").QueryReportResponse>;
                 reportsByOperator(request: import("./service/v1/query").QueryReportsByOperatorRequest): Promise<import("./service/v1/query").QueryReportsByOperatorResponse>;
                 operatorReputationSnapshot(request: import("./service/v1/query").QueryOperatorReputationSnapshotRequest): Promise<import("./service/v1/query").QueryOperatorReputationSnapshotResponse>;
+                checkpoint(request: import("./service/v1/query").QueryCheckpointRequest): Promise<import("./service/v1/query").QueryCheckpointResponse>;
+                checkpointsByServiceType(request: import("./service/v1/query").QueryCheckpointsByServiceTypeRequest): Promise<import("./service/v1/query").QueryCheckpointsByServiceTypeResponse>;
             };
         };
         session: {
@@ -601,6 +632,7 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
         sparkdream: {
             v1: {
                 params(request?: import("./sparkdream/v1/query").QueryParamsRequest): Promise<import("./sparkdream/v1/query").QueryParamsResponse>;
+                contentLicense(request?: import("./sparkdream/v1/query").QueryContentLicenseRequest): Promise<import("./sparkdream/v1/query").QueryContentLicenseResponse>;
             };
         };
         split: {

package/sparkdream/rpc.query.js

@@ -101,6 +101,9 @@ const createRPCQueryClient = async ({ rpcEndpoint }) => {
             }
         },
         sparkdream: {
+            artifact: {
+                v1: (await Promise.resolve().then(() => __importStar(require("./artifact/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
             blog: {
                 v1: (await Promise.resolve().then(() => __importStar(require("./blog/v1/query.rpc.Query")))).createRpcQueryExtension(client)
             },

package/sparkdream/rpc.tx.d.ts

@@ -54,6 +54,9 @@ export declare const createRPCMsgClient: ({ rpc }: {
         };
     };
     sparkdream: {
+        artifact: {
+            v1: import("./artifact/v1/tx.rpc.msg").MsgClientImpl;
+        };
         blog: {
             v1: import("./blog/v1/tx.rpc.msg").MsgClientImpl;
         };

package/sparkdream/rpc.tx.js

@@ -87,6 +87,9 @@ const createRPCMsgClient = async ({ rpc }) => ({
         }
     },
     sparkdream: {
+        artifact: {
+            v1: new (await Promise.resolve().then(() => __importStar(require("./artifact/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        },
         blog: {
             v1: new (await Promise.resolve().then(() => __importStar(require("./blog/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
         },

package/sparkdream/service/v1/checkpoint.d.ts

@@ -0,0 +1,93 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Checkpoint is an operator's latest progress claim for its off-chain work
+ * under one service type (MsgSubmitCheckpoint). Service-agnostic: for
+ * content scanners `height` is the block height scanned up to and `root` the
+ * merkle root of the operator's signed verdict feed up to that point
+ * (docs/content-scanning.md §8.2). One record per (service_type, operator);
+ * each submission replaces the previous one and must advance `height`.
+ * @name Checkpoint
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Checkpoint
+ */
+export interface Checkpoint {
+    operator: string;
+    serviceType: string;
+    /**
+     * height is how far the operator's work has progressed, in block height.
+     * Strictly increasing per operator; never above the block it lands in.
+     */
+    height: bigint;
+    /**
+     * root commits to the operator's off-chain output up to `height`
+     * (32 bytes). Makes the output tamper-evident: a later feed that does not
+     * reproduce an earlier root has been rewritten.
+     */
+    root: Uint8Array;
+    /**
+     * submitted_at is the block height the checkpoint landed in.
+     */
+    submittedAt: bigint;
+}
+export interface CheckpointProtoMsg {
+    typeUrl: "/sparkdream.service.v1.Checkpoint";
+    value: Uint8Array;
+}
+/**
+ * Checkpoint is an operator's latest progress claim for its off-chain work
+ * under one service type (MsgSubmitCheckpoint). Service-agnostic: for
+ * content scanners `height` is the block height scanned up to and `root` the
+ * merkle root of the operator's signed verdict feed up to that point
+ * (docs/content-scanning.md §8.2). One record per (service_type, operator);
+ * each submission replaces the previous one and must advance `height`.
+ * @name CheckpointAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Checkpoint
+ */
+export interface CheckpointAmino {
+    operator?: string;
+    service_type?: string;
+    /**
+     * height is how far the operator's work has progressed, in block height.
+     * Strictly increasing per operator; never above the block it lands in.
+     */
+    height?: string;
+    /**
+     * root commits to the operator's off-chain output up to `height`
+     * (32 bytes). Makes the output tamper-evident: a later feed that does not
+     * reproduce an earlier root has been rewritten.
+     */
+    root?: string;
+    /**
+     * submitted_at is the block height the checkpoint landed in.
+     */
+    submitted_at?: string;
+}
+export interface CheckpointAminoMsg {
+    type: "/sparkdream.service.v1.Checkpoint";
+    value: CheckpointAmino;
+}
+/**
+ * Checkpoint is an operator's latest progress claim for its off-chain work
+ * under one service type (MsgSubmitCheckpoint). Service-agnostic: for
+ * content scanners `height` is the block height scanned up to and `root` the
+ * merkle root of the operator's signed verdict feed up to that point
+ * (docs/content-scanning.md §8.2). One record per (service_type, operator);
+ * each submission replaces the previous one and must advance `height`.
+ * @name Checkpoint
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Checkpoint
+ */
+export declare const Checkpoint: {
+    typeUrl: string;
+    encode(message: Checkpoint, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Checkpoint;
+    fromPartial(object: DeepPartial<Checkpoint>): Checkpoint;
+    fromAmino(object: CheckpointAmino): Checkpoint;
+    toAmino(message: Checkpoint): CheckpointAmino;
+    fromAminoMsg(object: CheckpointAminoMsg): Checkpoint;
+    fromProtoMsg(message: CheckpointProtoMsg): Checkpoint;
+    toProto(message: Checkpoint): Uint8Array;
+    toProtoMsg(message: Checkpoint): CheckpointProtoMsg;
+};

package/sparkdream/service/v1/checkpoint.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checkpoint = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseCheckpoint() {
+    return {
+        operator: "",
+        serviceType: "",
+        height: BigInt(0),
+        root: new Uint8Array(),
+        submittedAt: BigInt(0)
+    };
+}
+/**
+ * Checkpoint is an operator's latest progress claim for its off-chain work
+ * under one service type (MsgSubmitCheckpoint). Service-agnostic: for
+ * content scanners `height` is the block height scanned up to and `root` the
+ * merkle root of the operator's signed verdict feed up to that point
+ * (docs/content-scanning.md §8.2). One record per (service_type, operator);
+ * each submission replaces the previous one and must advance `height`.
+ * @name Checkpoint
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Checkpoint
+ */
+exports.Checkpoint = {
+    typeUrl: "/sparkdream.service.v1.Checkpoint",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.operator !== "") {
+            writer.uint32(10).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(24).int64(message.height);
+        }
+        if (message.root.length !== 0) {
+            writer.uint32(34).bytes(message.root);
+        }
+        if (message.submittedAt !== BigInt(0)) {
+            writer.uint32(40).int64(message.submittedAt);
+        }
+        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 = createBaseCheckpoint();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operator = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.height = reader.int64();
+                    break;
+                case 4:
+                    message.root = reader.bytes();
+                    break;
+                case 5:
+                    message.submittedAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCheckpoint();
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+        message.root = object.root ?? new Uint8Array();
+        message.submittedAt = object.submittedAt !== undefined && object.submittedAt !== null ? BigInt(object.submittedAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCheckpoint();
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        if (object.root !== undefined && object.root !== null) {
+            message.root = (0, helpers_1.bytesFromBase64)(object.root);
+        }
+        if (object.submitted_at !== undefined && object.submitted_at !== null) {
+            message.submittedAt = BigInt(object.submitted_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+        obj.root = message.root ? (0, helpers_1.base64FromBytes)(message.root) : undefined;
+        obj.submitted_at = message.submittedAt !== BigInt(0) ? message.submittedAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Checkpoint.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Checkpoint.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Checkpoint.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Checkpoint",
+            value: exports.Checkpoint.encode(message).finish()
+        };
+    }
+};

package/sparkdream/service/v1/genesis.d.ts

@@ -7,6 +7,7 @@ import { ControllerTransferCase, ControllerTransferCaseAmino } from "./controlle
 import { ReporterRateLimit, ReporterRateLimitAmino } from "./reporter_rate_limit";
 import { RefileCooldown, RefileCooldownAmino } from "./refile_cooldown";
 import { Tier1LastSlash, Tier1LastSlashAmino } from "./tier1_last_slash";
+import { Checkpoint, CheckpointAmino } from "./checkpoint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
 /**
@@ -75,6 +76,13 @@ export interface GenesisState {
      * next_escrow_id restores the Tier1Escrow auto-incrementing counter.
      */
     nextEscrowId: bigint;
+    /**
+     * checkpoints are the latest MsgSubmitCheckpoint record per
+     * (service_type, operator). Liveness deadlines are not exported; they
+     * are rebuilt from checkpoints and each type's checkpoint_max_lag_blocks
+     * at import.
+     */
+    checkpoints: Checkpoint[];
 }
 export interface GenesisStateProtoMsg {
     typeUrl: "/sparkdream.service.v1.GenesisState";
@@ -146,6 +154,13 @@ export interface GenesisStateAmino {
      * next_escrow_id restores the Tier1Escrow auto-incrementing counter.
      */
     next_escrow_id?: string;
+    /**
+     * checkpoints are the latest MsgSubmitCheckpoint record per
+     * (service_type, operator). Liveness deadlines are not exported; they
+     * are rebuilt from checkpoints and each type's checkpoint_max_lag_blocks
+     * at import.
+     */
+    checkpoints?: CheckpointAmino[];
 }
 export interface GenesisStateAminoMsg {
     type: "/sparkdream.service.v1.GenesisState";

package/sparkdream/service/v1/genesis.js

@@ -11,6 +11,7 @@ const controller_transfer_case_1 = require("./controller_transfer_case");
 const reporter_rate_limit_1 = require("./reporter_rate_limit");
 const refile_cooldown_1 = require("./refile_cooldown");
 const tier1_last_slash_1 = require("./tier1_last_slash");
+const checkpoint_1 = require("./checkpoint");
 const binary_1 = require("../../../binary");
 function createBaseGenesisState() {
     return {
@@ -25,7 +26,8 @@ function createBaseGenesisState() {
         refileCooldowns: [],
         tier1LastSlash: [],
         nextReportId: BigInt(0),
-        nextEscrowId: BigInt(0)
+        nextEscrowId: BigInt(0),
+        checkpoints: []
     };
 }
 /**
@@ -74,6 +76,9 @@ exports.GenesisState = {
         if (message.nextEscrowId !== BigInt(0)) {
             writer.uint32(96).uint64(message.nextEscrowId);
         }
+        for (const v of message.checkpoints) {
+            checkpoint_1.Checkpoint.encode(v, writer.uint32(106).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
@@ -119,6 +124,9 @@ exports.GenesisState = {
                 case 12:
                     message.nextEscrowId = reader.uint64();
                     break;
+                case 13:
+                    message.checkpoints.push(checkpoint_1.Checkpoint.decode(reader, reader.uint32()));
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -140,6 +148,7 @@ exports.GenesisState = {
         message.tier1LastSlash = object.tier1LastSlash?.map(e => tier1_last_slash_1.Tier1LastSlash.fromPartial(e)) || [];
         message.nextReportId = object.nextReportId !== undefined && object.nextReportId !== null ? BigInt(object.nextReportId.toString()) : BigInt(0);
         message.nextEscrowId = object.nextEscrowId !== undefined && object.nextEscrowId !== null ? BigInt(object.nextEscrowId.toString()) : BigInt(0);
+        message.checkpoints = object.checkpoints?.map(e => checkpoint_1.Checkpoint.fromPartial(e)) || [];
         return message;
     },
     fromAmino(object) {
@@ -162,6 +171,7 @@ exports.GenesisState = {
         if (object.next_escrow_id !== undefined && object.next_escrow_id !== null) {
             message.nextEscrowId = BigInt(object.next_escrow_id);
         }
+        message.checkpoints = object.checkpoints?.map(e => checkpoint_1.Checkpoint.fromAmino(e)) || [];
         return message;
     },
     toAmino(message) {
@@ -223,6 +233,12 @@ exports.GenesisState = {
         }
         obj.next_report_id = message.nextReportId !== BigInt(0) ? message.nextReportId?.toString() : undefined;
         obj.next_escrow_id = message.nextEscrowId !== BigInt(0) ? message.nextEscrowId?.toString() : undefined;
+        if (message.checkpoints) {
+            obj.checkpoints = message.checkpoints.map(e => e ? checkpoint_1.Checkpoint.toAmino(e) : undefined);
+        }
+        else {
+            obj.checkpoints = message.checkpoints;
+        }
         return obj;
     },
     fromAminoMsg(object) {

package/sparkdream/service/v1/query.d.ts

@@ -3,6 +3,7 @@ import { Params, ParamsAmino } from "./params";
 import { Operator, OperatorAmino } from "./operator";
 import { ServiceTypeConfig, ServiceTypeConfigAmino } from "./service_type_config";
 import { Report, ReportAmino } from "./report";
+import { Checkpoint, CheckpointAmino } from "./checkpoint";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
 /**
@@ -601,6 +602,118 @@ export interface QueryOperatorReputationSnapshotResponseAminoMsg {
     type: "/sparkdream.service.v1.QueryOperatorReputationSnapshotResponse";
     value: QueryOperatorReputationSnapshotResponseAmino;
 }
+/**
+ * QueryCheckpointRequest selects one operator's checkpoint.
+ * @name QueryCheckpointRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointRequest
+ */
+export interface QueryCheckpointRequest {
+    operator: string;
+    serviceType: string;
+}
+export interface QueryCheckpointRequestProtoMsg {
+    typeUrl: "/sparkdream.service.v1.QueryCheckpointRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryCheckpointRequest selects one operator's checkpoint.
+ * @name QueryCheckpointRequestAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointRequest
+ */
+export interface QueryCheckpointRequestAmino {
+    operator?: string;
+    service_type?: string;
+}
+export interface QueryCheckpointRequestAminoMsg {
+    type: "/sparkdream.service.v1.QueryCheckpointRequest";
+    value: QueryCheckpointRequestAmino;
+}
+/**
+ * QueryCheckpointResponse returns the operator's latest checkpoint.
+ * @name QueryCheckpointResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointResponse
+ */
+export interface QueryCheckpointResponse {
+    checkpoint: Checkpoint;
+}
+export interface QueryCheckpointResponseProtoMsg {
+    typeUrl: "/sparkdream.service.v1.QueryCheckpointResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryCheckpointResponse returns the operator's latest checkpoint.
+ * @name QueryCheckpointResponseAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointResponse
+ */
+export interface QueryCheckpointResponseAmino {
+    checkpoint?: CheckpointAmino;
+}
+export interface QueryCheckpointResponseAminoMsg {
+    type: "/sparkdream.service.v1.QueryCheckpointResponse";
+    value: QueryCheckpointResponseAmino;
+}
+/**
+ * QueryCheckpointsByServiceTypeRequest pages a service type's checkpoints.
+ * @name QueryCheckpointsByServiceTypeRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointsByServiceTypeRequest
+ */
+export interface QueryCheckpointsByServiceTypeRequest {
+    serviceType: string;
+    pagination?: PageRequest;
+}
+export interface QueryCheckpointsByServiceTypeRequestProtoMsg {
+    typeUrl: "/sparkdream.service.v1.QueryCheckpointsByServiceTypeRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryCheckpointsByServiceTypeRequest pages a service type's checkpoints.
+ * @name QueryCheckpointsByServiceTypeRequestAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointsByServiceTypeRequest
+ */
+export interface QueryCheckpointsByServiceTypeRequestAmino {
+    service_type?: string;
+    pagination?: PageRequestAmino;
+}
+export interface QueryCheckpointsByServiceTypeRequestAminoMsg {
+    type: "/sparkdream.service.v1.QueryCheckpointsByServiceTypeRequest";
+    value: QueryCheckpointsByServiceTypeRequestAmino;
+}
+/**
+ * QueryCheckpointsByServiceTypeResponse lists checkpoints in operator
+ * address byte order.
+ * @name QueryCheckpointsByServiceTypeResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointsByServiceTypeResponse
+ */
+export interface QueryCheckpointsByServiceTypeResponse {
+    checkpoints: Checkpoint[];
+    pagination?: PageResponse;
+}
+export interface QueryCheckpointsByServiceTypeResponseProtoMsg {
+    typeUrl: "/sparkdream.service.v1.QueryCheckpointsByServiceTypeResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryCheckpointsByServiceTypeResponse lists checkpoints in operator
+ * address byte order.
+ * @name QueryCheckpointsByServiceTypeResponseAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointsByServiceTypeResponse
+ */
+export interface QueryCheckpointsByServiceTypeResponseAmino {
+    checkpoints?: CheckpointAmino[];
+    pagination?: PageResponseAmino;
+}
+export interface QueryCheckpointsByServiceTypeResponseAminoMsg {
+    type: "/sparkdream.service.v1.QueryCheckpointsByServiceTypeResponse";
+    value: QueryCheckpointsByServiceTypeResponseAmino;
+}
 /**
  * QueryParamsRequest is request type for the Query/Params RPC method.
  * @name QueryParamsRequest
@@ -962,3 +1075,76 @@ export declare const QueryOperatorReputationSnapshotResponse: {
     toProto(message: QueryOperatorReputationSnapshotResponse): Uint8Array;
     toProtoMsg(message: QueryOperatorReputationSnapshotResponse): QueryOperatorReputationSnapshotResponseProtoMsg;
 };
+/**
+ * QueryCheckpointRequest selects one operator's checkpoint.
+ * @name QueryCheckpointRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointRequest
+ */
+export declare const QueryCheckpointRequest: {
+    typeUrl: string;
+    encode(message: QueryCheckpointRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCheckpointRequest;
+    fromPartial(object: DeepPartial<QueryCheckpointRequest>): QueryCheckpointRequest;
+    fromAmino(object: QueryCheckpointRequestAmino): QueryCheckpointRequest;
+    toAmino(message: QueryCheckpointRequest): QueryCheckpointRequestAmino;
+    fromAminoMsg(object: QueryCheckpointRequestAminoMsg): QueryCheckpointRequest;
+    fromProtoMsg(message: QueryCheckpointRequestProtoMsg): QueryCheckpointRequest;
+    toProto(message: QueryCheckpointRequest): Uint8Array;
+    toProtoMsg(message: QueryCheckpointRequest): QueryCheckpointRequestProtoMsg;
+};
+/**
+ * QueryCheckpointResponse returns the operator's latest checkpoint.
+ * @name QueryCheckpointResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointResponse
+ */
+export declare const QueryCheckpointResponse: {
+    typeUrl: string;
+    encode(message: QueryCheckpointResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCheckpointResponse;
+    fromPartial(object: DeepPartial<QueryCheckpointResponse>): QueryCheckpointResponse;
+    fromAmino(object: QueryCheckpointResponseAmino): QueryCheckpointResponse;
+    toAmino(message: QueryCheckpointResponse): QueryCheckpointResponseAmino;
+    fromAminoMsg(object: QueryCheckpointResponseAminoMsg): QueryCheckpointResponse;
+    fromProtoMsg(message: QueryCheckpointResponseProtoMsg): QueryCheckpointResponse;
+    toProto(message: QueryCheckpointResponse): Uint8Array;
+    toProtoMsg(message: QueryCheckpointResponse): QueryCheckpointResponseProtoMsg;
+};
+/**
+ * QueryCheckpointsByServiceTypeRequest pages a service type's checkpoints.
+ * @name QueryCheckpointsByServiceTypeRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointsByServiceTypeRequest
+ */
+export declare const QueryCheckpointsByServiceTypeRequest: {
+    typeUrl: string;
+    encode(message: QueryCheckpointsByServiceTypeRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCheckpointsByServiceTypeRequest;
+    fromPartial(object: DeepPartial<QueryCheckpointsByServiceTypeRequest>): QueryCheckpointsByServiceTypeRequest;
+    fromAmino(object: QueryCheckpointsByServiceTypeRequestAmino): QueryCheckpointsByServiceTypeRequest;
+    toAmino(message: QueryCheckpointsByServiceTypeRequest): QueryCheckpointsByServiceTypeRequestAmino;
+    fromAminoMsg(object: QueryCheckpointsByServiceTypeRequestAminoMsg): QueryCheckpointsByServiceTypeRequest;
+    fromProtoMsg(message: QueryCheckpointsByServiceTypeRequestProtoMsg): QueryCheckpointsByServiceTypeRequest;
+    toProto(message: QueryCheckpointsByServiceTypeRequest): Uint8Array;
+    toProtoMsg(message: QueryCheckpointsByServiceTypeRequest): QueryCheckpointsByServiceTypeRequestProtoMsg;
+};
+/**
+ * QueryCheckpointsByServiceTypeResponse lists checkpoints in operator
+ * address byte order.
+ * @name QueryCheckpointsByServiceTypeResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryCheckpointsByServiceTypeResponse
+ */
+export declare const QueryCheckpointsByServiceTypeResponse: {
+    typeUrl: string;
+    encode(message: QueryCheckpointsByServiceTypeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCheckpointsByServiceTypeResponse;
+    fromPartial(object: DeepPartial<QueryCheckpointsByServiceTypeResponse>): QueryCheckpointsByServiceTypeResponse;
+    fromAmino(object: QueryCheckpointsByServiceTypeResponseAmino): QueryCheckpointsByServiceTypeResponse;
+    toAmino(message: QueryCheckpointsByServiceTypeResponse): QueryCheckpointsByServiceTypeResponseAmino;
+    fromAminoMsg(object: QueryCheckpointsByServiceTypeResponseAminoMsg): QueryCheckpointsByServiceTypeResponse;
+    fromProtoMsg(message: QueryCheckpointsByServiceTypeResponseProtoMsg): QueryCheckpointsByServiceTypeResponse;
+    toProto(message: QueryCheckpointsByServiceTypeResponse): Uint8Array;
+    toProtoMsg(message: QueryCheckpointsByServiceTypeResponse): QueryCheckpointsByServiceTypeResponseProtoMsg;
+};