@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.18

package/sparkdream/service/v1/system_report_rate_limit.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemReportRateLimit = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../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
+ */
+exports.SystemReportRateLimit = {
+    typeUrl: "/sparkdream.service.v1.SystemReportRateLimit",
+    aminoType: "sparkdream/x/service/SystemReportRateLimit",
+    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 exports.SystemReportRateLimit.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/SystemReportRateLimit",
+            value: exports.SystemReportRateLimit.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.SystemReportRateLimit.decode(message.value);
+    },
+    toProto(message) {
+        return exports.SystemReportRateLimit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.SystemReportRateLimit",
+            value: exports.SystemReportRateLimit.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,125 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * 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 interface Tier1EscrowEntry {
+    /**
+     * escrow_id is the auto-incrementing primary key (NextEscrowID counter).
+     */
+    escrowId: bigint;
+    /**
+     * report_id is the report this escrow corresponds to (the tier-1
+     * resolution that produced the slash).
+     */
+    reportId: bigint;
+    /**
+     * operator_address is the operator whose bond was reduced.
+     */
+    operatorAddress: string;
+    /**
+     * service_type identifies which operator record this affects.
+     */
+    serviceType: string;
+    /**
+     * amount is the SPARK held in escrow, in bond-denom micro-units.
+     * Wrapped into sdk.Coin with the chain's bond denom at the point of
+     * use.
+     */
+    amount: string;
+    /**
+     * release_at is the height at which the escrow becomes eligible for
+     * release to the community pool (set to current_height +
+     * report_contest_window_blocks at lock time).
+     */
+    releaseAt: bigint;
+}
+export interface Tier1EscrowEntryProtoMsg {
+    typeUrl: "/sparkdream.service.v1.Tier1EscrowEntry";
+    value: Uint8Array;
+}
+/**
+ * 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 Tier1EscrowEntryAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Tier1EscrowEntry
+ */
+export interface Tier1EscrowEntryAmino {
+    /**
+     * escrow_id is the auto-incrementing primary key (NextEscrowID counter).
+     */
+    escrow_id?: string;
+    /**
+     * report_id is the report this escrow corresponds to (the tier-1
+     * resolution that produced the slash).
+     */
+    report_id?: string;
+    /**
+     * operator_address is the operator whose bond was reduced.
+     */
+    operator_address?: string;
+    /**
+     * service_type identifies which operator record this affects.
+     */
+    service_type?: string;
+    /**
+     * amount is the SPARK held in escrow, in bond-denom micro-units.
+     * Wrapped into sdk.Coin with the chain's bond denom at the point of
+     * use.
+     */
+    amount?: string;
+    /**
+     * release_at is the height at which the escrow becomes eligible for
+     * release to the community pool (set to current_height +
+     * report_contest_window_blocks at lock time).
+     */
+    release_at?: string;
+}
+export interface Tier1EscrowEntryAminoMsg {
+    type: "sparkdream/x/service/Tier1EscrowEntry";
+    value: Tier1EscrowEntryAmino;
+}
+/**
+ * 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 declare const Tier1EscrowEntry: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Tier1EscrowEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Tier1EscrowEntry;
+    fromPartial(object: DeepPartial<Tier1EscrowEntry>): Tier1EscrowEntry;
+    fromAmino(object: Tier1EscrowEntryAmino): Tier1EscrowEntry;
+    toAmino(message: Tier1EscrowEntry): Tier1EscrowEntryAmino;
+    fromAminoMsg(object: Tier1EscrowEntryAminoMsg): Tier1EscrowEntry;
+    toAminoMsg(message: Tier1EscrowEntry): Tier1EscrowEntryAminoMsg;
+    fromProtoMsg(message: Tier1EscrowEntryProtoMsg): Tier1EscrowEntry;
+    toProto(message: Tier1EscrowEntry): Uint8Array;
+    toProtoMsg(message: Tier1EscrowEntry): Tier1EscrowEntryProtoMsg;
+};

package/sparkdream/service/v1/tier1_escrow_entry.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tier1EscrowEntry = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../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
+ */
+exports.Tier1EscrowEntry = {
+    typeUrl: "/sparkdream.service.v1.Tier1EscrowEntry",
+    aminoType: "sparkdream/x/service/Tier1EscrowEntry",
+    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 exports.Tier1EscrowEntry.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Tier1EscrowEntry",
+            value: exports.Tier1EscrowEntry.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Tier1EscrowEntry.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Tier1EscrowEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Tier1EscrowEntry",
+            value: exports.Tier1EscrowEntry.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,101 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * 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 interface Tier1LastSlash {
+    /**
+     * controller is the controller whose cooldown is tracked.
+     */
+    controller: string;
+    /**
+     * operator_address is the target operator.
+     */
+    operatorAddress: string;
+    /**
+     * service_type identifies the operator record.
+     */
+    serviceType: string;
+    /**
+     * last_slash_height is the block height of the most recent tier-1
+     * slash by this controller against this operator.
+     */
+    lastSlashHeight: bigint;
+}
+export interface Tier1LastSlashProtoMsg {
+    typeUrl: "/sparkdream.service.v1.Tier1LastSlash";
+    value: Uint8Array;
+}
+/**
+ * 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 Tier1LastSlashAmino
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.Tier1LastSlash
+ */
+export interface Tier1LastSlashAmino {
+    /**
+     * controller is the controller whose cooldown is tracked.
+     */
+    controller?: string;
+    /**
+     * operator_address is the target operator.
+     */
+    operator_address?: string;
+    /**
+     * service_type identifies the operator record.
+     */
+    service_type?: string;
+    /**
+     * last_slash_height is the block height of the most recent tier-1
+     * slash by this controller against this operator.
+     */
+    last_slash_height?: string;
+}
+export interface Tier1LastSlashAminoMsg {
+    type: "sparkdream/x/service/Tier1LastSlash";
+    value: Tier1LastSlashAmino;
+}
+/**
+ * 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 declare const Tier1LastSlash: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Tier1LastSlash, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Tier1LastSlash;
+    fromPartial(object: DeepPartial<Tier1LastSlash>): Tier1LastSlash;
+    fromAmino(object: Tier1LastSlashAmino): Tier1LastSlash;
+    toAmino(message: Tier1LastSlash): Tier1LastSlashAmino;
+    fromAminoMsg(object: Tier1LastSlashAminoMsg): Tier1LastSlash;
+    toAminoMsg(message: Tier1LastSlash): Tier1LastSlashAminoMsg;
+    fromProtoMsg(message: Tier1LastSlashProtoMsg): Tier1LastSlash;
+    toProto(message: Tier1LastSlash): Uint8Array;
+    toProtoMsg(message: Tier1LastSlash): Tier1LastSlashProtoMsg;
+};

package/sparkdream/service/v1/tier1_last_slash.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tier1LastSlash = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../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
+ */
+exports.Tier1LastSlash = {
+    typeUrl: "/sparkdream.service.v1.Tier1LastSlash",
+    aminoType: "sparkdream/x/service/Tier1LastSlash",
+    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 exports.Tier1LastSlash.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/Tier1LastSlash",
+            value: exports.Tier1LastSlash.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Tier1LastSlash.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Tier1LastSlash.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.Tier1LastSlash",
+            value: exports.Tier1LastSlash.encode(message).finish()
+        };
+    }
+};

package/sparkdream/service/v1/tx.amino.d.ts

@@ -0,0 +1,68 @@
+import { MsgUpdateParams, MsgUpdateServiceTypeConfig, MsgRegisterOperator, MsgUpdateMetadata, MsgUnbondOperator, MsgClaimUnbondedBond, MsgTopUpBond, MsgReportOperator, MsgResolveReport, MsgContestSlash, MsgResolveReportByJury, MsgOpenControllerTransferCase, MsgFinalizeControllerTransfer } from "./tx";
+export declare const AminoConverter: {
+    "/sparkdream.service.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+    "/sparkdream.service.v1.MsgUpdateServiceTypeConfig": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateServiceTypeConfig) => import("./tx").MsgUpdateServiceTypeConfigAmino;
+        fromAmino: (object: import("./tx").MsgUpdateServiceTypeConfigAmino) => MsgUpdateServiceTypeConfig;
+    };
+    "/sparkdream.service.v1.MsgRegisterOperator": {
+        aminoType: string;
+        toAmino: (message: MsgRegisterOperator) => import("./tx").MsgRegisterOperatorAmino;
+        fromAmino: (object: import("./tx").MsgRegisterOperatorAmino) => MsgRegisterOperator;
+    };
+    "/sparkdream.service.v1.MsgUpdateMetadata": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateMetadata) => import("./tx").MsgUpdateMetadataAmino;
+        fromAmino: (object: import("./tx").MsgUpdateMetadataAmino) => MsgUpdateMetadata;
+    };
+    "/sparkdream.service.v1.MsgUnbondOperator": {
+        aminoType: string;
+        toAmino: (message: MsgUnbondOperator) => import("./tx").MsgUnbondOperatorAmino;
+        fromAmino: (object: import("./tx").MsgUnbondOperatorAmino) => MsgUnbondOperator;
+    };
+    "/sparkdream.service.v1.MsgClaimUnbondedBond": {
+        aminoType: string;
+        toAmino: (message: MsgClaimUnbondedBond) => import("./tx").MsgClaimUnbondedBondAmino;
+        fromAmino: (object: import("./tx").MsgClaimUnbondedBondAmino) => MsgClaimUnbondedBond;
+    };
+    "/sparkdream.service.v1.MsgTopUpBond": {
+        aminoType: string;
+        toAmino: (message: MsgTopUpBond) => import("./tx").MsgTopUpBondAmino;
+        fromAmino: (object: import("./tx").MsgTopUpBondAmino) => MsgTopUpBond;
+    };
+    "/sparkdream.service.v1.MsgReportOperator": {
+        aminoType: string;
+        toAmino: (message: MsgReportOperator) => import("./tx").MsgReportOperatorAmino;
+        fromAmino: (object: import("./tx").MsgReportOperatorAmino) => MsgReportOperator;
+    };
+    "/sparkdream.service.v1.MsgResolveReport": {
+        aminoType: string;
+        toAmino: (message: MsgResolveReport) => import("./tx").MsgResolveReportAmino;
+        fromAmino: (object: import("./tx").MsgResolveReportAmino) => MsgResolveReport;
+    };
+    "/sparkdream.service.v1.MsgContestSlash": {
+        aminoType: string;
+        toAmino: (message: MsgContestSlash) => import("./tx").MsgContestSlashAmino;
+        fromAmino: (object: import("./tx").MsgContestSlashAmino) => MsgContestSlash;
+    };
+    "/sparkdream.service.v1.MsgResolveReportByJury": {
+        aminoType: string;
+        toAmino: (message: MsgResolveReportByJury) => import("./tx").MsgResolveReportByJuryAmino;
+        fromAmino: (object: import("./tx").MsgResolveReportByJuryAmino) => MsgResolveReportByJury;
+    };
+    "/sparkdream.service.v1.MsgOpenControllerTransferCase": {
+        aminoType: string;
+        toAmino: (message: MsgOpenControllerTransferCase) => import("./tx").MsgOpenControllerTransferCaseAmino;
+        fromAmino: (object: import("./tx").MsgOpenControllerTransferCaseAmino) => MsgOpenControllerTransferCase;
+    };
+    "/sparkdream.service.v1.MsgFinalizeControllerTransfer": {
+        aminoType: string;
+        toAmino: (message: MsgFinalizeControllerTransfer) => import("./tx").MsgFinalizeControllerTransferAmino;
+        fromAmino: (object: import("./tx").MsgFinalizeControllerTransferAmino) => MsgFinalizeControllerTransfer;
+    };
+};