@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.19

package/esm/sparkdream/service/v1/query.lcd.js

@@ -0,0 +1,107 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/service/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* Operator returns the live operator record for (address, service_type). */
+    operator = async (params) => {
+        const endpoint = `sparkdream/service/v1/operator/${params.address}/${params.serviceType}`;
+        return await this.req.get(endpoint);
+    };
+    /* ServiceType returns one service-type registry entry. */
+    serviceType = async (params) => {
+        const endpoint = `sparkdream/service/v1/service_type/${params.serviceType}`;
+        return await this.req.get(endpoint);
+    };
+    /* ServiceTypes returns all service-type registry entries (paginated). */
+    serviceTypes = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.enabledOnly !== "undefined") {
+            options.params.enabled_only = params.enabledOnly;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/service_types`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Operators returns all live operator records (paginated, optionally
+     filtered by status). */
+    operators = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/operators`;
+        return await this.req.get(endpoint, options);
+    };
+    /* OperatorsByController returns live operators whose controller is the
+     given address. */
+    operatorsByController = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/operators_by_controller/${params.controller}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* OperatorsByServiceType returns live operators of the given service type. */
+    operatorsByServiceType = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/operators_by_service_type/${params.serviceType}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Report returns a single report by id. */
+    report = async (params) => {
+        const endpoint = `sparkdream/service/v1/report/${params.reportId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ReportsByOperator returns reports against (operator_address, service_type). */
+    reportsByOperator = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.statusFilter !== "undefined") {
+            options.params.status_filter = params.statusFilter;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `sparkdream/service/v1/reports_by_operator/${params.operatorAddress}/${params.serviceType}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* OperatorReputationSnapshot returns bond-block totals for an address
+     (§6.6 lazy accrual visibility). Settles in-memory at query time; no
+     state write. */
+    operatorReputationSnapshot = async (params) => {
+        const endpoint = `sparkdream/service/v1/operator_reputation_snapshot/${params.address}`;
+        return await this.req.get(endpoint);
+    };
+}

package/esm/sparkdream/service/v1/query.rpc.Query.js

@@ -0,0 +1,109 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryOperatorRequest, QueryOperatorResponse, QueryServiceTypeRequest, QueryServiceTypeResponse, QueryServiceTypesRequest, QueryServiceTypesResponse, QueryOperatorsRequest, QueryOperatorsResponse, QueryOperatorsByControllerRequest, QueryOperatorsByControllerResponse, QueryOperatorsByServiceTypeRequest, QueryOperatorsByServiceTypeResponse, QueryReportRequest, QueryReportResponse, QueryReportsByOperatorRequest, QueryReportsByOperatorResponse, QueryOperatorReputationSnapshotRequest, QueryOperatorReputationSnapshotResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Params", data);
+        return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+    };
+    /* Operator returns the live operator record for (address, service_type). */
+    operator = async (request) => {
+        const data = QueryOperatorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Operator", data);
+        return promise.then(data => QueryOperatorResponse.decode(new BinaryReader(data)));
+    };
+    /* ServiceType returns one service-type registry entry. */
+    serviceType = async (request) => {
+        const data = QueryServiceTypeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "ServiceType", data);
+        return promise.then(data => QueryServiceTypeResponse.decode(new BinaryReader(data)));
+    };
+    /* ServiceTypes returns all service-type registry entries (paginated). */
+    serviceTypes = async (request) => {
+        const data = QueryServiceTypesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "ServiceTypes", data);
+        return promise.then(data => QueryServiceTypesResponse.decode(new BinaryReader(data)));
+    };
+    /* Operators returns all live operator records (paginated, optionally
+     filtered by status). */
+    operators = async (request) => {
+        const data = QueryOperatorsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Operators", data);
+        return promise.then(data => QueryOperatorsResponse.decode(new BinaryReader(data)));
+    };
+    /* OperatorsByController returns live operators whose controller is the
+     given address. */
+    operatorsByController = async (request) => {
+        const data = QueryOperatorsByControllerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "OperatorsByController", data);
+        return promise.then(data => QueryOperatorsByControllerResponse.decode(new BinaryReader(data)));
+    };
+    /* OperatorsByServiceType returns live operators of the given service type. */
+    operatorsByServiceType = async (request) => {
+        const data = QueryOperatorsByServiceTypeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "OperatorsByServiceType", data);
+        return promise.then(data => QueryOperatorsByServiceTypeResponse.decode(new BinaryReader(data)));
+    };
+    /* Report returns a single report by id. */
+    report = async (request) => {
+        const data = QueryReportRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "Report", data);
+        return promise.then(data => QueryReportResponse.decode(new BinaryReader(data)));
+    };
+    /* ReportsByOperator returns reports against (operator_address, service_type). */
+    reportsByOperator = async (request) => {
+        const data = QueryReportsByOperatorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "ReportsByOperator", data);
+        return promise.then(data => QueryReportsByOperatorResponse.decode(new BinaryReader(data)));
+    };
+    /* OperatorReputationSnapshot returns bond-block totals for an address
+     (§6.6 lazy accrual visibility). Settles in-memory at query time; no
+     state write. */
+    operatorReputationSnapshot = async (request) => {
+        const data = QueryOperatorReputationSnapshotRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.service.v1.Query", "OperatorReputationSnapshot", data);
+        return promise.then(data => QueryOperatorReputationSnapshotResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        operator(request) {
+            return queryService.operator(request);
+        },
+        serviceType(request) {
+            return queryService.serviceType(request);
+        },
+        serviceTypes(request) {
+            return queryService.serviceTypes(request);
+        },
+        operators(request) {
+            return queryService.operators(request);
+        },
+        operatorsByController(request) {
+            return queryService.operatorsByController(request);
+        },
+        operatorsByServiceType(request) {
+            return queryService.operatorsByServiceType(request);
+        },
+        report(request) {
+            return queryService.report(request);
+        },
+        reportsByOperator(request) {
+            return queryService.reportsByOperator(request);
+        },
+        operatorReputationSnapshot(request) {
+            return queryService.operatorReputationSnapshot(request);
+        }
+    };
+};

package/esm/sparkdream/service/v1/refile_cooldown.js

@@ -0,0 +1,121 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseRefileCooldown() {
+    return {
+        controller: "",
+        operatorAddress: "",
+        serviceType: "",
+        dismissedAt: BigInt(0)
+    };
+}
+/**
+ * RefileCooldown bars a controller from re-filing the same allegation
+ * against the same (operator, service_type) within
+ * `report_refile_cooldown_blocks` after a PENDING report was
+ * AUTO_DISMISSED (controller stall). See x-service-spec.md §3.4.5.
+ *
+ * Keyed by (controller, operator_address, service_type, dismissed_at)
+ * in the RefileCooldowns store; lazy expiry — entries are checked at
+ * MsgReportOperator time and pruned when expired.
+ * @name RefileCooldown
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.RefileCooldown
+ */
+export const RefileCooldown = {
+    typeUrl: "/sparkdream.service.v1.RefileCooldown",
+    aminoType: "sparkdream/x/service/RefileCooldown",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.controller !== "") {
+            writer.uint32(10).string(message.controller);
+        }
+        if (message.operatorAddress !== "") {
+            writer.uint32(18).string(message.operatorAddress);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(26).string(message.serviceType);
+        }
+        if (message.dismissedAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.dismissedAt);
+        }
+        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 = createBaseRefileCooldown();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.controller = reader.string();
+                    break;
+                case 2:
+                    message.operatorAddress = reader.string();
+                    break;
+                case 3:
+                    message.serviceType = reader.string();
+                    break;
+                case 4:
+                    message.dismissedAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRefileCooldown();
+        message.controller = object.controller ?? "";
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.dismissedAt = object.dismissedAt !== undefined && object.dismissedAt !== null ? BigInt(object.dismissedAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRefileCooldown();
+        if (object.controller !== undefined && object.controller !== null) {
+            message.controller = object.controller;
+        }
+        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.dismissed_at !== undefined && object.dismissed_at !== null) {
+            message.dismissedAt = BigInt(object.dismissed_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.controller = message.controller === "" ? undefined : message.controller;
+        obj.operator_address = message.operatorAddress === "" ? undefined : message.operatorAddress;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.dismissed_at = message.dismissedAt !== BigInt(0) ? message.dismissedAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RefileCooldown.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/RefileCooldown",
+            value: RefileCooldown.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return RefileCooldown.decode(message.value);
+    },
+    toProto(message) {
+        return RefileCooldown.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.RefileCooldown",
+            value: RefileCooldown.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/service/v1/report.js

@@ -0,0 +1,212 @@
+import { BinaryReader, BinaryWriter } from "../../../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
+ */
+export const Report = {
+    typeUrl: "/sparkdream.service.v1.Report",
+    aminoType: "sparkdream/x/service/Report",
+    encode(message, writer = 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 BinaryReader ? input : new 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 Report.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Report",
+            value: Report.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Report.decode(message.value);
+    },
+    toProto(message) {
+        return Report.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Report",
+            value: Report.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/service/v1/reporter_rate_limit.js

@@ -0,0 +1,137 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../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
+ */
+export const ReporterRateLimit = {
+    typeUrl: "/sparkdream.service.v1.ReporterRateLimit",
+    aminoType: "sparkdream/x/service/ReporterRateLimit",
+    encode(message, writer = 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 BinaryReader ? input : new 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 ReporterRateLimit.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/ReporterRateLimit",
+            value: ReporterRateLimit.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return ReporterRateLimit.decode(message.value);
+    },
+    toProto(message) {
+        return ReporterRateLimit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.ReporterRateLimit",
+            value: ReporterRateLimit.encode(message).finish()
+        };
+    }
+};