@sparkdreamnft/sparkdreamjs 0.0.16 → 0.0.18

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

@@ -0,0 +1,264 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * ReportTimeoutAction controls what the EndBlocker does when a PENDING
+ * report ages past max_pending_blocks without a controller verdict.
+ * Per-service-type knob so consumer modules can pick the failure-mode
+ * best suited to their accountability model (see Phase 0 of the
+ * federation→service migration plan).
+ */
+export var ReportTimeoutAction;
+(function (ReportTimeoutAction) {
+    /**
+     * REPORT_TIMEOUT_ACTION_DISMISS - REPORT_TIMEOUT_ACTION_DISMISS is the default: aged reports auto-
+     * dismiss, deposit refunded to reporter, controller barred from
+     * re-filing the same allegation for report_refile_cooldown_blocks.
+     * Suits service types where "no decision" should default to the
+     * operator's benefit.
+     */
+    ReportTimeoutAction[ReportTimeoutAction["REPORT_TIMEOUT_ACTION_DISMISS"] = 0] = "REPORT_TIMEOUT_ACTION_DISMISS";
+    /**
+     * REPORT_TIMEOUT_ACTION_ESCALATE - REPORT_TIMEOUT_ACTION_ESCALATE auto-opens an x/rep jury case via
+     * CreateAppealInitiative when the controller stalls. Suits service
+     * types where a silent/captured controller must not be able to park
+     * a slash indefinitely (e.g. federation bridges).
+     */
+    ReportTimeoutAction[ReportTimeoutAction["REPORT_TIMEOUT_ACTION_ESCALATE"] = 1] = "REPORT_TIMEOUT_ACTION_ESCALATE";
+    ReportTimeoutAction[ReportTimeoutAction["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ReportTimeoutAction || (ReportTimeoutAction = {}));
+export const ReportTimeoutActionAmino = ReportTimeoutAction;
+export function reportTimeoutActionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "REPORT_TIMEOUT_ACTION_DISMISS":
+            return ReportTimeoutAction.REPORT_TIMEOUT_ACTION_DISMISS;
+        case 1:
+        case "REPORT_TIMEOUT_ACTION_ESCALATE":
+            return ReportTimeoutAction.REPORT_TIMEOUT_ACTION_ESCALATE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ReportTimeoutAction.UNRECOGNIZED;
+    }
+}
+export function reportTimeoutActionToJSON(object) {
+    switch (object) {
+        case ReportTimeoutAction.REPORT_TIMEOUT_ACTION_DISMISS:
+            return "REPORT_TIMEOUT_ACTION_DISMISS";
+        case ReportTimeoutAction.REPORT_TIMEOUT_ACTION_ESCALATE:
+            return "REPORT_TIMEOUT_ACTION_ESCALATE";
+        case ReportTimeoutAction.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseServiceTypeConfig() {
+    return {
+        serviceType: "",
+        description: "",
+        minBondAmount: "",
+        unbondingPeriodBlocks: BigInt(0),
+        unilateralSlashCapBps: 0,
+        tier1WindowBlocks: BigInt(0),
+        tier1AggregateCapBps: 0,
+        tier1CooldownBlocks: BigInt(0),
+        underfundedGraceBlocks: BigInt(0),
+        enabled: false,
+        reportTimeoutAction: 0,
+        challengeDefaultSlashBps: 0
+    };
+}
+/**
+ * ServiceTypeConfig is the governance-managed allowlist entry that defines
+ * a permitted service type and its per-type knobs (see x-service-spec.md
+ * §3.2). Mutated only via MsgUpdateServiceTypeConfig (gov authority).
+ * @name ServiceTypeConfig
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.ServiceTypeConfig
+ */
+export const ServiceTypeConfig = {
+    typeUrl: "/sparkdream.service.v1.ServiceTypeConfig",
+    aminoType: "sparkdream/x/service/ServiceTypeConfig",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.serviceType !== "") {
+            writer.uint32(10).string(message.serviceType);
+        }
+        if (message.description !== "") {
+            writer.uint32(18).string(message.description);
+        }
+        if (message.minBondAmount !== "") {
+            writer.uint32(26).string(message.minBondAmount);
+        }
+        if (message.unbondingPeriodBlocks !== BigInt(0)) {
+            writer.uint32(32).int64(message.unbondingPeriodBlocks);
+        }
+        if (message.unilateralSlashCapBps !== 0) {
+            writer.uint32(40).uint32(message.unilateralSlashCapBps);
+        }
+        if (message.tier1WindowBlocks !== BigInt(0)) {
+            writer.uint32(48).int64(message.tier1WindowBlocks);
+        }
+        if (message.tier1AggregateCapBps !== 0) {
+            writer.uint32(56).uint32(message.tier1AggregateCapBps);
+        }
+        if (message.tier1CooldownBlocks !== BigInt(0)) {
+            writer.uint32(64).int64(message.tier1CooldownBlocks);
+        }
+        if (message.underfundedGraceBlocks !== BigInt(0)) {
+            writer.uint32(72).int64(message.underfundedGraceBlocks);
+        }
+        if (message.enabled === true) {
+            writer.uint32(80).bool(message.enabled);
+        }
+        if (message.reportTimeoutAction !== 0) {
+            writer.uint32(88).int32(message.reportTimeoutAction);
+        }
+        if (message.challengeDefaultSlashBps !== 0) {
+            writer.uint32(96).uint32(message.challengeDefaultSlashBps);
+        }
+        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 = createBaseServiceTypeConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.serviceType = reader.string();
+                    break;
+                case 2:
+                    message.description = reader.string();
+                    break;
+                case 3:
+                    message.minBondAmount = reader.string();
+                    break;
+                case 4:
+                    message.unbondingPeriodBlocks = reader.int64();
+                    break;
+                case 5:
+                    message.unilateralSlashCapBps = reader.uint32();
+                    break;
+                case 6:
+                    message.tier1WindowBlocks = reader.int64();
+                    break;
+                case 7:
+                    message.tier1AggregateCapBps = reader.uint32();
+                    break;
+                case 8:
+                    message.tier1CooldownBlocks = reader.int64();
+                    break;
+                case 9:
+                    message.underfundedGraceBlocks = reader.int64();
+                    break;
+                case 10:
+                    message.enabled = reader.bool();
+                    break;
+                case 11:
+                    message.reportTimeoutAction = reader.int32();
+                    break;
+                case 12:
+                    message.challengeDefaultSlashBps = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseServiceTypeConfig();
+        message.serviceType = object.serviceType ?? "";
+        message.description = object.description ?? "";
+        message.minBondAmount = object.minBondAmount ?? "";
+        message.unbondingPeriodBlocks = object.unbondingPeriodBlocks !== undefined && object.unbondingPeriodBlocks !== null ? BigInt(object.unbondingPeriodBlocks.toString()) : BigInt(0);
+        message.unilateralSlashCapBps = object.unilateralSlashCapBps ?? 0;
+        message.tier1WindowBlocks = object.tier1WindowBlocks !== undefined && object.tier1WindowBlocks !== null ? BigInt(object.tier1WindowBlocks.toString()) : BigInt(0);
+        message.tier1AggregateCapBps = object.tier1AggregateCapBps ?? 0;
+        message.tier1CooldownBlocks = object.tier1CooldownBlocks !== undefined && object.tier1CooldownBlocks !== null ? BigInt(object.tier1CooldownBlocks.toString()) : BigInt(0);
+        message.underfundedGraceBlocks = object.underfundedGraceBlocks !== undefined && object.underfundedGraceBlocks !== null ? BigInt(object.underfundedGraceBlocks.toString()) : BigInt(0);
+        message.enabled = object.enabled ?? false;
+        message.reportTimeoutAction = object.reportTimeoutAction ?? 0;
+        message.challengeDefaultSlashBps = object.challengeDefaultSlashBps ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseServiceTypeConfig();
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.min_bond_amount !== undefined && object.min_bond_amount !== null) {
+            message.minBondAmount = object.min_bond_amount;
+        }
+        if (object.unbonding_period_blocks !== undefined && object.unbonding_period_blocks !== null) {
+            message.unbondingPeriodBlocks = BigInt(object.unbonding_period_blocks);
+        }
+        if (object.unilateral_slash_cap_bps !== undefined && object.unilateral_slash_cap_bps !== null) {
+            message.unilateralSlashCapBps = object.unilateral_slash_cap_bps;
+        }
+        if (object.tier1_window_blocks !== undefined && object.tier1_window_blocks !== null) {
+            message.tier1WindowBlocks = BigInt(object.tier1_window_blocks);
+        }
+        if (object.tier1_aggregate_cap_bps !== undefined && object.tier1_aggregate_cap_bps !== null) {
+            message.tier1AggregateCapBps = object.tier1_aggregate_cap_bps;
+        }
+        if (object.tier1_cooldown_blocks !== undefined && object.tier1_cooldown_blocks !== null) {
+            message.tier1CooldownBlocks = BigInt(object.tier1_cooldown_blocks);
+        }
+        if (object.underfunded_grace_blocks !== undefined && object.underfunded_grace_blocks !== null) {
+            message.underfundedGraceBlocks = BigInt(object.underfunded_grace_blocks);
+        }
+        if (object.enabled !== undefined && object.enabled !== null) {
+            message.enabled = object.enabled;
+        }
+        if (object.report_timeout_action !== undefined && object.report_timeout_action !== null) {
+            message.reportTimeoutAction = object.report_timeout_action;
+        }
+        if (object.challenge_default_slash_bps !== undefined && object.challenge_default_slash_bps !== null) {
+            message.challengeDefaultSlashBps = object.challenge_default_slash_bps;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.min_bond_amount = message.minBondAmount === "" ? undefined : message.minBondAmount;
+        obj.unbonding_period_blocks = message.unbondingPeriodBlocks !== BigInt(0) ? message.unbondingPeriodBlocks?.toString() : undefined;
+        obj.unilateral_slash_cap_bps = message.unilateralSlashCapBps === 0 ? undefined : message.unilateralSlashCapBps;
+        obj.tier1_window_blocks = message.tier1WindowBlocks !== BigInt(0) ? message.tier1WindowBlocks?.toString() : undefined;
+        obj.tier1_aggregate_cap_bps = message.tier1AggregateCapBps === 0 ? undefined : message.tier1AggregateCapBps;
+        obj.tier1_cooldown_blocks = message.tier1CooldownBlocks !== BigInt(0) ? message.tier1CooldownBlocks?.toString() : undefined;
+        obj.underfunded_grace_blocks = message.underfundedGraceBlocks !== BigInt(0) ? message.underfundedGraceBlocks?.toString() : undefined;
+        obj.enabled = message.enabled === false ? undefined : message.enabled;
+        obj.report_timeout_action = message.reportTimeoutAction === 0 ? undefined : message.reportTimeoutAction;
+        obj.challenge_default_slash_bps = message.challengeDefaultSlashBps === 0 ? undefined : message.challengeDefaultSlashBps;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ServiceTypeConfig.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/ServiceTypeConfig",
+            value: ServiceTypeConfig.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return ServiceTypeConfig.decode(message.value);
+    },
+    toProto(message) {
+        return ServiceTypeConfig.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.ServiceTypeConfig",
+            value: ServiceTypeConfig.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,115 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseSystemReportRateLimit() {
+    return {
+        callerModule: "",
+        recentFilingHeights: []
+    };
+}
+/**
+ * SystemReportRateLimit tracks recent OpenSystemReport call heights for
+ * a given allowlisted caller module (e.g. "federation"), implementing
+ * the sliding-window per-caller cap from Phase 0 of the federation→
+ * service migration plan.
+ *
+ * The keeper admits a new system-report filing iff fewer than
+ * `max_system_reports_per_caller_per_window` entries in
+ * `recent_filing_heights` fall within
+ * `[current_height - rate_limit_window_blocks, current_height]`.
+ *
+ * Ring-buffer semantics: when at capacity, the oldest entry is
+ * overwritten on each new filing. Idempotent re-calls (same dedupe_key
+ * resolving to an existing report) do NOT update the ring buffer.
+ * @name SystemReportRateLimit
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.SystemReportRateLimit
+ */
+export const SystemReportRateLimit = {
+    typeUrl: "/sparkdream.service.v1.SystemReportRateLimit",
+    aminoType: "sparkdream/x/service/SystemReportRateLimit",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.callerModule !== "") {
+            writer.uint32(10).string(message.callerModule);
+        }
+        writer.uint32(18).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 = createBaseSystemReportRateLimit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.callerModule = reader.string();
+                    break;
+                case 2:
+                    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 = createBaseSystemReportRateLimit();
+        message.callerModule = object.callerModule ?? "";
+        message.recentFilingHeights = object.recentFilingHeights?.map(e => BigInt(e.toString())) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSystemReportRateLimit();
+        if (object.caller_module !== undefined && object.caller_module !== null) {
+            message.callerModule = object.caller_module;
+        }
+        message.recentFilingHeights = object.recent_filing_heights?.map(e => BigInt(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.caller_module = message.callerModule === "" ? undefined : message.callerModule;
+        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 SystemReportRateLimit.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/SystemReportRateLimit",
+            value: SystemReportRateLimit.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return SystemReportRateLimit.decode(message.value);
+    },
+    toProto(message) {
+        return SystemReportRateLimit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.SystemReportRateLimit",
+            value: SystemReportRateLimit.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,145 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseTier1EscrowEntry() {
+    return {
+        escrowId: BigInt(0),
+        reportId: BigInt(0),
+        operatorAddress: "",
+        serviceType: "",
+        amount: "",
+        releaseAt: BigInt(0)
+    };
+}
+/**
+ * Tier1EscrowEntry holds a tier-1 slash that has been moved out of the
+ * operator's bond but not yet released to the community pool — pending
+ * either the contest window expiring (release to pool) or the operator
+ * contesting (return to bond). See x-service-spec.md §3.4.7.
+ *
+ * Keyed by `escrow_id` (auto-incrementing uint64) in the Tier1Escrow
+ * store; secondary index by operator (Tier1EscrowByOperator) and by
+ * release height (Tier1EscrowReleaseQueue for the EndBlocker sweep).
+ * @name Tier1EscrowEntry
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Tier1EscrowEntry
+ */
+export const Tier1EscrowEntry = {
+    typeUrl: "/sparkdream.service.v1.Tier1EscrowEntry",
+    aminoType: "sparkdream/x/service/Tier1EscrowEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.escrowId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.escrowId);
+        }
+        if (message.reportId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.reportId);
+        }
+        if (message.operatorAddress !== "") {
+            writer.uint32(26).string(message.operatorAddress);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(34).string(message.serviceType);
+        }
+        if (message.amount !== "") {
+            writer.uint32(42).string(message.amount);
+        }
+        if (message.releaseAt !== BigInt(0)) {
+            writer.uint32(48).int64(message.releaseAt);
+        }
+        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 = createBaseTier1EscrowEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.escrowId = reader.uint64();
+                    break;
+                case 2:
+                    message.reportId = reader.uint64();
+                    break;
+                case 3:
+                    message.operatorAddress = reader.string();
+                    break;
+                case 4:
+                    message.serviceType = reader.string();
+                    break;
+                case 5:
+                    message.amount = reader.string();
+                    break;
+                case 6:
+                    message.releaseAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTier1EscrowEntry();
+        message.escrowId = object.escrowId !== undefined && object.escrowId !== null ? BigInt(object.escrowId.toString()) : BigInt(0);
+        message.reportId = object.reportId !== undefined && object.reportId !== null ? BigInt(object.reportId.toString()) : BigInt(0);
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.amount = object.amount ?? "";
+        message.releaseAt = object.releaseAt !== undefined && object.releaseAt !== null ? BigInt(object.releaseAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTier1EscrowEntry();
+        if (object.escrow_id !== undefined && object.escrow_id !== null) {
+            message.escrowId = BigInt(object.escrow_id);
+        }
+        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.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        if (object.release_at !== undefined && object.release_at !== null) {
+            message.releaseAt = BigInt(object.release_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.escrow_id = message.escrowId !== BigInt(0) ? message.escrowId?.toString() : undefined;
+        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.amount = message.amount === "" ? undefined : message.amount;
+        obj.release_at = message.releaseAt !== BigInt(0) ? message.releaseAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Tier1EscrowEntry.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Tier1EscrowEntry",
+            value: Tier1EscrowEntry.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Tier1EscrowEntry.decode(message.value);
+    },
+    toProto(message) {
+        return Tier1EscrowEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Tier1EscrowEntry",
+            value: Tier1EscrowEntry.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,121 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseTier1LastSlash() {
+    return {
+        controller: "",
+        operatorAddress: "",
+        serviceType: "",
+        lastSlashHeight: BigInt(0)
+    };
+}
+/**
+ * Tier1LastSlash records the height of the most recent tier-1 slash
+ * applied by a given (controller, operator, service_type) tuple,
+ * consulted to enforce `tier1_cooldown_blocks` (see x-service-spec.md
+ * §3.4.4 and §4.1).
+ *
+ * Pruned when the operator record archives (BOTH SLASHED and RETIRED
+ * transitions) so a re-registered operator never inherits cooldown
+ * state from a prior incarnation.
+ * @name Tier1LastSlash
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Tier1LastSlash
+ */
+export const Tier1LastSlash = {
+    typeUrl: "/sparkdream.service.v1.Tier1LastSlash",
+    aminoType: "sparkdream/x/service/Tier1LastSlash",
+    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.lastSlashHeight !== BigInt(0)) {
+            writer.uint32(32).int64(message.lastSlashHeight);
+        }
+        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 = createBaseTier1LastSlash();
+        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.lastSlashHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTier1LastSlash();
+        message.controller = object.controller ?? "";
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.lastSlashHeight = object.lastSlashHeight !== undefined && object.lastSlashHeight !== null ? BigInt(object.lastSlashHeight.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTier1LastSlash();
+        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.last_slash_height !== undefined && object.last_slash_height !== null) {
+            message.lastSlashHeight = BigInt(object.last_slash_height);
+        }
+        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.last_slash_height = message.lastSlashHeight !== BigInt(0) ? message.lastSlashHeight?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Tier1LastSlash.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Tier1LastSlash",
+            value: Tier1LastSlash.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Tier1LastSlash.decode(message.value);
+    },
+    toProto(message) {
+        return Tier1LastSlash.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Tier1LastSlash",
+            value: Tier1LastSlash.encode(message).finish()
+        };
+    }
+};