@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.18

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

@@ -0,0 +1,174 @@
+import { ReportStatus } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Report is a single report filed against an operator (see x-service-spec.md
+ * §3.4 and §4.1). Keyed by `report_id` (auto-incrementing uint64); secondary
+ * indexes by operator (ReportsByOperator) and by status for the PENDING /
+ * ESCALATED EndBlocker sweeps.
+ * @name Report
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Report
+ */
+export interface Report {
+    /**
+     * report_id is the auto-incrementing primary key (NextReportID counter).
+     */
+    reportId: bigint;
+    /**
+     * operator_address is the target operator's bech32 address.
+     */
+    operatorAddress: string;
+    /**
+     * service_type identifies which operator record this report targets
+     * (an address may have multiple operators across service types).
+     */
+    serviceType: string;
+    /**
+     * reporter is the bech32 address of the member who filed the report.
+     */
+    reporter: string;
+    /**
+     * reason is free-form human-readable text, capped by `max_reason_bytes`.
+     */
+    reason: string;
+    /**
+     * filed_at is the height the report was filed.
+     */
+    filedAt: bigint;
+    /**
+     * escalated_at is the height the report transitioned to ESCALATED; 0
+     * otherwise. Feeds the auto-timeout sweep (§3.6 queue 3).
+     */
+    escalatedAt: bigint;
+    /**
+     * status is the lifecycle status (§3.4.5).
+     */
+    status: ReportStatus;
+    /**
+     * proposed_slash_bps is set when the controller escalates with a
+     * specific proposal (or carried forward on operator contest); the jury
+     * verdict is bounded by this value (§5.2).
+     */
+    proposedSlashBps: number;
+    /**
+     * slash_amount is the SPARK amount actually slashed once the report
+     * resolves, in bond-denom micro-units. Zero for PENDING /
+     * RESOLVED_T1-with-dismiss / AUTO_*. Wrapped into sdk.Coin with the
+     * chain's bond denom at the point of use.
+     */
+    slashAmount: string;
+    /**
+     * deposit is the SPARK the reporter escrowed at filing time
+     * (`report_deposit_amount` param), in bond-denom micro-units. Held in
+     * the report deposit pool until resolution. Wrapped into sdk.Coin with
+     * the chain's bond denom at the point of use.
+     */
+    deposit: string;
+    /**
+     * jury_case_id is the x/rep case id opened on escalation; 0 if never
+     * escalated.
+     */
+    juryCaseId: bigint;
+}
+export interface ReportProtoMsg {
+    typeUrl: "/sparkdream.service.v1.Report";
+    value: Uint8Array;
+}
+/**
+ * Report is a single report filed against an operator (see x-service-spec.md
+ * §3.4 and §4.1). Keyed by `report_id` (auto-incrementing uint64); secondary
+ * indexes by operator (ReportsByOperator) and by status for the PENDING /
+ * ESCALATED EndBlocker sweeps.
+ * @name ReportAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Report
+ */
+export interface ReportAmino {
+    /**
+     * report_id is the auto-incrementing primary key (NextReportID counter).
+     */
+    report_id?: string;
+    /**
+     * operator_address is the target operator's bech32 address.
+     */
+    operator_address?: string;
+    /**
+     * service_type identifies which operator record this report targets
+     * (an address may have multiple operators across service types).
+     */
+    service_type?: string;
+    /**
+     * reporter is the bech32 address of the member who filed the report.
+     */
+    reporter?: string;
+    /**
+     * reason is free-form human-readable text, capped by `max_reason_bytes`.
+     */
+    reason?: string;
+    /**
+     * filed_at is the height the report was filed.
+     */
+    filed_at?: string;
+    /**
+     * escalated_at is the height the report transitioned to ESCALATED; 0
+     * otherwise. Feeds the auto-timeout sweep (§3.6 queue 3).
+     */
+    escalated_at?: string;
+    /**
+     * status is the lifecycle status (§3.4.5).
+     */
+    status?: ReportStatus;
+    /**
+     * proposed_slash_bps is set when the controller escalates with a
+     * specific proposal (or carried forward on operator contest); the jury
+     * verdict is bounded by this value (§5.2).
+     */
+    proposed_slash_bps?: number;
+    /**
+     * slash_amount is the SPARK amount actually slashed once the report
+     * resolves, in bond-denom micro-units. Zero for PENDING /
+     * RESOLVED_T1-with-dismiss / AUTO_*. Wrapped into sdk.Coin with the
+     * chain's bond denom at the point of use.
+     */
+    slash_amount?: string;
+    /**
+     * deposit is the SPARK the reporter escrowed at filing time
+     * (`report_deposit_amount` param), in bond-denom micro-units. Held in
+     * the report deposit pool until resolution. Wrapped into sdk.Coin with
+     * the chain's bond denom at the point of use.
+     */
+    deposit?: string;
+    /**
+     * jury_case_id is the x/rep case id opened on escalation; 0 if never
+     * escalated.
+     */
+    jury_case_id?: string;
+}
+export interface ReportAminoMsg {
+    type: "sparkdream/x/service/Report";
+    value: ReportAmino;
+}
+/**
+ * Report is a single report filed against an operator (see x-service-spec.md
+ * §3.4 and §4.1). Keyed by `report_id` (auto-incrementing uint64); secondary
+ * indexes by operator (ReportsByOperator) and by status for the PENDING /
+ * ESCALATED EndBlocker sweeps.
+ * @name Report
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Report
+ */
+export declare const Report: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Report, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Report;
+    fromPartial(object: DeepPartial<Report>): Report;
+    fromAmino(object: ReportAmino): Report;
+    toAmino(message: Report): ReportAmino;
+    fromAminoMsg(object: ReportAminoMsg): Report;
+    toAminoMsg(message: Report): ReportAminoMsg;
+    fromProtoMsg(message: ReportProtoMsg): Report;
+    toProto(message: Report): Uint8Array;
+    toProtoMsg(message: Report): ReportProtoMsg;
+};

package/sparkdream/service/v1/report.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Report = void 0;
+const binary_1 = require("../../../binary");
+function createBaseReport() {
+    return {
+        reportId: BigInt(0),
+        operatorAddress: "",
+        serviceType: "",
+        reporter: "",
+        reason: "",
+        filedAt: BigInt(0),
+        escalatedAt: BigInt(0),
+        status: 0,
+        proposedSlashBps: 0,
+        slashAmount: "",
+        deposit: "",
+        juryCaseId: BigInt(0)
+    };
+}
+/**
+ * Report is a single report filed against an operator (see x-service-spec.md
+ * §3.4 and §4.1). Keyed by `report_id` (auto-incrementing uint64); secondary
+ * indexes by operator (ReportsByOperator) and by status for the PENDING /
+ * ESCALATED EndBlocker sweeps.
+ * @name Report
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Report
+ */
+exports.Report = {
+    typeUrl: "/sparkdream.service.v1.Report",
+    aminoType: "sparkdream/x/service/Report",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.reportId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.reportId);
+        }
+        if (message.operatorAddress !== "") {
+            writer.uint32(18).string(message.operatorAddress);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(26).string(message.serviceType);
+        }
+        if (message.reporter !== "") {
+            writer.uint32(34).string(message.reporter);
+        }
+        if (message.reason !== "") {
+            writer.uint32(42).string(message.reason);
+        }
+        if (message.filedAt !== BigInt(0)) {
+            writer.uint32(48).int64(message.filedAt);
+        }
+        if (message.escalatedAt !== BigInt(0)) {
+            writer.uint32(56).int64(message.escalatedAt);
+        }
+        if (message.status !== 0) {
+            writer.uint32(64).int32(message.status);
+        }
+        if (message.proposedSlashBps !== 0) {
+            writer.uint32(72).uint32(message.proposedSlashBps);
+        }
+        if (message.slashAmount !== "") {
+            writer.uint32(82).string(message.slashAmount);
+        }
+        if (message.deposit !== "") {
+            writer.uint32(90).string(message.deposit);
+        }
+        if (message.juryCaseId !== BigInt(0)) {
+            writer.uint32(96).uint64(message.juryCaseId);
+        }
+        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 = createBaseReport();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reportId = reader.uint64();
+                    break;
+                case 2:
+                    message.operatorAddress = reader.string();
+                    break;
+                case 3:
+                    message.serviceType = reader.string();
+                    break;
+                case 4:
+                    message.reporter = reader.string();
+                    break;
+                case 5:
+                    message.reason = reader.string();
+                    break;
+                case 6:
+                    message.filedAt = reader.int64();
+                    break;
+                case 7:
+                    message.escalatedAt = reader.int64();
+                    break;
+                case 8:
+                    message.status = reader.int32();
+                    break;
+                case 9:
+                    message.proposedSlashBps = reader.uint32();
+                    break;
+                case 10:
+                    message.slashAmount = reader.string();
+                    break;
+                case 11:
+                    message.deposit = reader.string();
+                    break;
+                case 12:
+                    message.juryCaseId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReport();
+        message.reportId = object.reportId !== undefined && object.reportId !== null ? BigInt(object.reportId.toString()) : BigInt(0);
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.reporter = object.reporter ?? "";
+        message.reason = object.reason ?? "";
+        message.filedAt = object.filedAt !== undefined && object.filedAt !== null ? BigInt(object.filedAt.toString()) : BigInt(0);
+        message.escalatedAt = object.escalatedAt !== undefined && object.escalatedAt !== null ? BigInt(object.escalatedAt.toString()) : BigInt(0);
+        message.status = object.status ?? 0;
+        message.proposedSlashBps = object.proposedSlashBps ?? 0;
+        message.slashAmount = object.slashAmount ?? "";
+        message.deposit = object.deposit ?? "";
+        message.juryCaseId = object.juryCaseId !== undefined && object.juryCaseId !== null ? BigInt(object.juryCaseId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReport();
+        if (object.report_id !== undefined && object.report_id !== null) {
+            message.reportId = BigInt(object.report_id);
+        }
+        if (object.operator_address !== undefined && object.operator_address !== null) {
+            message.operatorAddress = object.operator_address;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.reporter !== undefined && object.reporter !== null) {
+            message.reporter = object.reporter;
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        if (object.filed_at !== undefined && object.filed_at !== null) {
+            message.filedAt = BigInt(object.filed_at);
+        }
+        if (object.escalated_at !== undefined && object.escalated_at !== null) {
+            message.escalatedAt = BigInt(object.escalated_at);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.proposed_slash_bps !== undefined && object.proposed_slash_bps !== null) {
+            message.proposedSlashBps = object.proposed_slash_bps;
+        }
+        if (object.slash_amount !== undefined && object.slash_amount !== null) {
+            message.slashAmount = object.slash_amount;
+        }
+        if (object.deposit !== undefined && object.deposit !== null) {
+            message.deposit = object.deposit;
+        }
+        if (object.jury_case_id !== undefined && object.jury_case_id !== null) {
+            message.juryCaseId = BigInt(object.jury_case_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.report_id = message.reportId !== BigInt(0) ? message.reportId?.toString() : undefined;
+        obj.operator_address = message.operatorAddress === "" ? undefined : message.operatorAddress;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.reporter = message.reporter === "" ? undefined : message.reporter;
+        obj.reason = message.reason === "" ? undefined : message.reason;
+        obj.filed_at = message.filedAt !== BigInt(0) ? message.filedAt?.toString() : undefined;
+        obj.escalated_at = message.escalatedAt !== BigInt(0) ? message.escalatedAt?.toString() : undefined;
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.proposed_slash_bps = message.proposedSlashBps === 0 ? undefined : message.proposedSlashBps;
+        obj.slash_amount = message.slashAmount === "" ? undefined : message.slashAmount;
+        obj.deposit = message.deposit === "" ? undefined : message.deposit;
+        obj.jury_case_id = message.juryCaseId !== BigInt(0) ? message.juryCaseId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Report.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Report",
+            value: exports.Report.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Report.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Report.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Report",
+            value: exports.Report.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,112 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * ReporterRateLimit tracks recent filing heights for a given
+ * (reporter, operator_address, service_type) tuple, implementing the
+ * sliding-window per-reporter cap from §3.4.6.
+ *
+ * The keeper admits a new filing iff fewer than
+ * `max_reports_per_reporter_per_operator_per_window` entries in
+ * `recent_filing_heights` fall within
+ * `[current_height - reporter_rate_limit_window_blocks, current_height]`.
+ *
+ * Ring-buffer semantics: when at capacity, the oldest entry is
+ * overwritten on each new filing.
+ * @name ReporterRateLimit
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.ReporterRateLimit
+ */
+export interface ReporterRateLimit {
+    /**
+     * reporter is the bech32 address whose rate is being tracked.
+     */
+    reporter: string;
+    /**
+     * operator_address is the target operator.
+     */
+    operatorAddress: string;
+    /**
+     * service_type is the target operator record.
+     */
+    serviceType: string;
+    /**
+     * recent_filing_heights is the ring buffer of recent filing heights
+     * (most-recent-first or in insertion order; the keeper documents
+     * which). Length capped at max_reports + 1.
+     */
+    recentFilingHeights: bigint[];
+}
+export interface ReporterRateLimitProtoMsg {
+    typeUrl: "/sparkdream.service.v1.ReporterRateLimit";
+    value: Uint8Array;
+}
+/**
+ * ReporterRateLimit tracks recent filing heights for a given
+ * (reporter, operator_address, service_type) tuple, implementing the
+ * sliding-window per-reporter cap from §3.4.6.
+ *
+ * The keeper admits a new filing iff fewer than
+ * `max_reports_per_reporter_per_operator_per_window` entries in
+ * `recent_filing_heights` fall within
+ * `[current_height - reporter_rate_limit_window_blocks, current_height]`.
+ *
+ * Ring-buffer semantics: when at capacity, the oldest entry is
+ * overwritten on each new filing.
+ * @name ReporterRateLimitAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.ReporterRateLimit
+ */
+export interface ReporterRateLimitAmino {
+    /**
+     * reporter is the bech32 address whose rate is being tracked.
+     */
+    reporter?: string;
+    /**
+     * operator_address is the target operator.
+     */
+    operator_address?: string;
+    /**
+     * service_type is the target operator record.
+     */
+    service_type?: string;
+    /**
+     * recent_filing_heights is the ring buffer of recent filing heights
+     * (most-recent-first or in insertion order; the keeper documents
+     * which). Length capped at max_reports + 1.
+     */
+    recent_filing_heights?: string[];
+}
+export interface ReporterRateLimitAminoMsg {
+    type: "sparkdream/x/service/ReporterRateLimit";
+    value: ReporterRateLimitAmino;
+}
+/**
+ * ReporterRateLimit tracks recent filing heights for a given
+ * (reporter, operator_address, service_type) tuple, implementing the
+ * sliding-window per-reporter cap from §3.4.6.
+ *
+ * The keeper admits a new filing iff fewer than
+ * `max_reports_per_reporter_per_operator_per_window` entries in
+ * `recent_filing_heights` fall within
+ * `[current_height - reporter_rate_limit_window_blocks, current_height]`.
+ *
+ * Ring-buffer semantics: when at capacity, the oldest entry is
+ * overwritten on each new filing.
+ * @name ReporterRateLimit
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.ReporterRateLimit
+ */
+export declare const ReporterRateLimit: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: ReporterRateLimit, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ReporterRateLimit;
+    fromPartial(object: DeepPartial<ReporterRateLimit>): ReporterRateLimit;
+    fromAmino(object: ReporterRateLimitAmino): ReporterRateLimit;
+    toAmino(message: ReporterRateLimit): ReporterRateLimitAmino;
+    fromAminoMsg(object: ReporterRateLimitAminoMsg): ReporterRateLimit;
+    toAminoMsg(message: ReporterRateLimit): ReporterRateLimitAminoMsg;
+    fromProtoMsg(message: ReporterRateLimitProtoMsg): ReporterRateLimit;
+    toProto(message: ReporterRateLimit): Uint8Array;
+    toProtoMsg(message: ReporterRateLimit): ReporterRateLimitProtoMsg;
+};

package/sparkdream/service/v1/reporter_rate_limit.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReporterRateLimit = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseReporterRateLimit() {
+    return {
+        reporter: "",
+        operatorAddress: "",
+        serviceType: "",
+        recentFilingHeights: []
+    };
+}
+/**
+ * ReporterRateLimit tracks recent filing heights for a given
+ * (reporter, operator_address, service_type) tuple, implementing the
+ * sliding-window per-reporter cap from §3.4.6.
+ *
+ * The keeper admits a new filing iff fewer than
+ * `max_reports_per_reporter_per_operator_per_window` entries in
+ * `recent_filing_heights` fall within
+ * `[current_height - reporter_rate_limit_window_blocks, current_height]`.
+ *
+ * Ring-buffer semantics: when at capacity, the oldest entry is
+ * overwritten on each new filing.
+ * @name ReporterRateLimit
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.ReporterRateLimit
+ */
+exports.ReporterRateLimit = {
+    typeUrl: "/sparkdream.service.v1.ReporterRateLimit",
+    aminoType: "sparkdream/x/service/ReporterRateLimit",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.reporter !== "") {
+            writer.uint32(10).string(message.reporter);
+        }
+        if (message.operatorAddress !== "") {
+            writer.uint32(18).string(message.operatorAddress);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(26).string(message.serviceType);
+        }
+        writer.uint32(34).fork();
+        for (const v of message.recentFilingHeights) {
+            writer.int64(v);
+        }
+        writer.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 = createBaseReporterRateLimit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reporter = reader.string();
+                    break;
+                case 2:
+                    message.operatorAddress = reader.string();
+                    break;
+                case 3:
+                    message.serviceType = reader.string();
+                    break;
+                case 4:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.recentFilingHeights.push(reader.int64());
+                        }
+                    }
+                    else {
+                        message.recentFilingHeights.push(reader.int64());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReporterRateLimit();
+        message.reporter = object.reporter ?? "";
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.recentFilingHeights = object.recentFilingHeights?.map(e => BigInt(e.toString())) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReporterRateLimit();
+        if (object.reporter !== undefined && object.reporter !== null) {
+            message.reporter = object.reporter;
+        }
+        if (object.operator_address !== undefined && object.operator_address !== null) {
+            message.operatorAddress = object.operator_address;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        message.recentFilingHeights = object.recent_filing_heights?.map(e => BigInt(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.reporter = message.reporter === "" ? undefined : message.reporter;
+        obj.operator_address = message.operatorAddress === "" ? undefined : message.operatorAddress;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        if (message.recentFilingHeights) {
+            obj.recent_filing_heights = message.recentFilingHeights.map(e => e.toString());
+        }
+        else {
+            obj.recent_filing_heights = message.recentFilingHeights;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ReporterRateLimit.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/ReporterRateLimit",
+            value: exports.ReporterRateLimit.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.ReporterRateLimit.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ReporterRateLimit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.ReporterRateLimit",
+            value: exports.ReporterRateLimit.encode(message).finish()
+        };
+    }
+};