@sparkdreamnft/sparkdreamjs 0.0.48 → 0.0.50

package/sparkdream/rep/v1/member_report.d.ts

@@ -1,4 +1,5 @@
 import { GovActionType, MemberReportStatus } from "./accountability";
+import { MemberStatus, TrustLevel } from "./member";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
 /**
@@ -25,6 +26,16 @@ export interface MemberReport {
      * an averaged share, to prevent cross-signer bond theft.
      */
     reporterBonds: ReporterBondEntry[];
+    /**
+     * resolved_action is the action MsgResolveMemberReport applied
+     * (UNSPECIFIED = dismissed). Together with resolved_at it opens the
+     * member's MsgAppealGovAction filing window.
+     */
+    resolvedAction: GovActionType;
+    /**
+     * resolved_at is the block time of the resolution (0 while open).
+     */
+    resolvedAt: bigint;
 }
 export interface MemberReportProtoMsg {
     typeUrl: "/sparkdream.rep.v1.MemberReport";
@@ -54,6 +65,16 @@ export interface MemberReportAmino {
      * an averaged share, to prevent cross-signer bond theft.
      */
     reporter_bonds?: ReporterBondEntryAmino[];
+    /**
+     * resolved_action is the action MsgResolveMemberReport applied
+     * (UNSPECIFIED = dismissed). Together with resolved_at it opens the
+     * member's MsgAppealGovAction filing window.
+     */
+    resolved_action?: GovActionType;
+    /**
+     * resolved_at is the block time of the resolution (0 while open).
+     */
+    resolved_at?: string;
 }
 export interface MemberReportAminoMsg {
     type: "/sparkdream.rep.v1.MemberReport";
@@ -89,6 +110,162 @@ export interface ReporterBondEntryAminoMsg {
     type: "/sparkdream.rep.v1.ReporterBondEntry";
     value: ReporterBondEntryAmino;
 }
+/**
+ * @name MemberActionRestoration_ReputationEntry
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.undefined
+ */
+export interface MemberActionRestoration_ReputationEntry {
+    key: string;
+    value: string;
+}
+export interface MemberActionRestoration_ReputationEntryProtoMsg {
+    typeUrl: string;
+    value: Uint8Array;
+}
+/**
+ * @name MemberActionRestoration_ReputationEntryAmino
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MemberActionRestoration_ReputationEntry
+ */
+export interface MemberActionRestoration_ReputationEntryAmino {
+    key?: string;
+    value?: string;
+}
+export interface MemberActionRestoration_ReputationEntryAminoMsg {
+    type: string;
+    value: MemberActionRestoration_ReputationEntryAmino;
+}
+/**
+ * MemberActionRestoration is what an OVERTURNED member-action appeal needs to
+ * undo the action MsgResolveMemberReport applied. Written at resolution, keyed
+ * by the member's canonical address (re-keyed by a migration), and deleted when
+ * the appeal reaches any terminal outcome or the filing window closes with no
+ * appeal, so at most one exists per member and only while the action is
+ * appealable.
+ * @name MemberActionRestoration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MemberActionRestoration
+ */
+export interface MemberActionRestoration {
+    member: string;
+    /**
+     * action is WARNING, DEMOTION or ZEROING.
+     */
+    action: GovActionType;
+    /**
+     * resolved_at is the block time of the resolution; the filing window closes
+     * at resolved_at + DefaultAppealDeadline.
+     */
+    resolvedAt: bigint;
+    /**
+     * season is the season the action was applied in. Reputation restored in a
+     * later season goes to the lifetime archive, which the season reset would
+     * have moved it to.
+     */
+    season: bigint;
+    /**
+     * warning_id is the MemberWarning a WARNING created.
+     */
+    warningId: bigint;
+    /**
+     * reputation is, for DEMOTION, the reputation the slash took per tag and,
+     * for ZEROING, the member's per-tag seasonal reputation before the zeroing.
+     */
+    reputation: {
+        [key: string]: string;
+    };
+    /**
+     * ZEROING only: the member's state before the zeroing, and the zeroed_count
+     * the zeroing produced (a later, unrelated zeroing changes it and blocks
+     * the restoration).
+     */
+    priorStatus: MemberStatus;
+    priorTrustLevel: TrustLevel;
+    priorInvitationCredits: number;
+    /**
+     * burned_dream is the liquid DREAM the zeroing burned from the balance.
+     * Escrows the zeroing forfeited (challenge stakes, invitation stakes, role
+     * and report bonds) are not included and are never restored.
+     */
+    burnedDream: string;
+    zeroedCount: number;
+    /**
+     * appealed is set once MsgAppealGovAction files the (single) appeal of the
+     * action; appeal_id is that appeal. Its outcome settles the record.
+     */
+    appealed: boolean;
+    appealId: bigint;
+}
+export interface MemberActionRestorationProtoMsg {
+    typeUrl: "/sparkdream.rep.v1.MemberActionRestoration";
+    value: Uint8Array;
+}
+/**
+ * MemberActionRestoration is what an OVERTURNED member-action appeal needs to
+ * undo the action MsgResolveMemberReport applied. Written at resolution, keyed
+ * by the member's canonical address (re-keyed by a migration), and deleted when
+ * the appeal reaches any terminal outcome or the filing window closes with no
+ * appeal, so at most one exists per member and only while the action is
+ * appealable.
+ * @name MemberActionRestorationAmino
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MemberActionRestoration
+ */
+export interface MemberActionRestorationAmino {
+    member?: string;
+    /**
+     * action is WARNING, DEMOTION or ZEROING.
+     */
+    action?: GovActionType;
+    /**
+     * resolved_at is the block time of the resolution; the filing window closes
+     * at resolved_at + DefaultAppealDeadline.
+     */
+    resolved_at?: string;
+    /**
+     * season is the season the action was applied in. Reputation restored in a
+     * later season goes to the lifetime archive, which the season reset would
+     * have moved it to.
+     */
+    season?: string;
+    /**
+     * warning_id is the MemberWarning a WARNING created.
+     */
+    warning_id?: string;
+    /**
+     * reputation is, for DEMOTION, the reputation the slash took per tag and,
+     * for ZEROING, the member's per-tag seasonal reputation before the zeroing.
+     */
+    reputation?: {
+        [key: string]: string;
+    };
+    /**
+     * ZEROING only: the member's state before the zeroing, and the zeroed_count
+     * the zeroing produced (a later, unrelated zeroing changes it and blocks
+     * the restoration).
+     */
+    prior_status?: MemberStatus;
+    prior_trust_level?: TrustLevel;
+    prior_invitation_credits?: number;
+    /**
+     * burned_dream is the liquid DREAM the zeroing burned from the balance.
+     * Escrows the zeroing forfeited (challenge stakes, invitation stakes, role
+     * and report bonds) are not included and are never restored.
+     */
+    burned_dream?: string;
+    zeroed_count?: number;
+    /**
+     * appealed is set once MsgAppealGovAction files the (single) appeal of the
+     * action; appeal_id is that appeal. Its outcome settles the record.
+     */
+    appealed?: boolean;
+    appeal_id?: string;
+}
+export interface MemberActionRestorationAminoMsg {
+    type: "/sparkdream.rep.v1.MemberActionRestoration";
+    value: MemberActionRestorationAmino;
+}
 /**
  * MemberReport defines the MemberReport message.
  * @name MemberReport
@@ -126,3 +303,41 @@ export declare const ReporterBondEntry: {
     toProto(message: ReporterBondEntry): Uint8Array;
     toProtoMsg(message: ReporterBondEntry): ReporterBondEntryProtoMsg;
 };
+/**
+ * @name MemberActionRestoration_ReputationEntry
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.undefined
+ */
+export declare const MemberActionRestoration_ReputationEntry: {
+    encode(message: MemberActionRestoration_ReputationEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MemberActionRestoration_ReputationEntry;
+    fromPartial(object: DeepPartial<MemberActionRestoration_ReputationEntry>): MemberActionRestoration_ReputationEntry;
+    fromAmino(object: MemberActionRestoration_ReputationEntryAmino): MemberActionRestoration_ReputationEntry;
+    toAmino(message: MemberActionRestoration_ReputationEntry): MemberActionRestoration_ReputationEntryAmino;
+    fromAminoMsg(object: MemberActionRestoration_ReputationEntryAminoMsg): MemberActionRestoration_ReputationEntry;
+    fromProtoMsg(message: MemberActionRestoration_ReputationEntryProtoMsg): MemberActionRestoration_ReputationEntry;
+    toProto(message: MemberActionRestoration_ReputationEntry): Uint8Array;
+};
+/**
+ * MemberActionRestoration is what an OVERTURNED member-action appeal needs to
+ * undo the action MsgResolveMemberReport applied. Written at resolution, keyed
+ * by the member's canonical address (re-keyed by a migration), and deleted when
+ * the appeal reaches any terminal outcome or the filing window closes with no
+ * appeal, so at most one exists per member and only while the action is
+ * appealable.
+ * @name MemberActionRestoration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MemberActionRestoration
+ */
+export declare const MemberActionRestoration: {
+    typeUrl: string;
+    encode(message: MemberActionRestoration, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MemberActionRestoration;
+    fromPartial(object: DeepPartial<MemberActionRestoration>): MemberActionRestoration;
+    fromAmino(object: MemberActionRestorationAmino): MemberActionRestoration;
+    toAmino(message: MemberActionRestoration): MemberActionRestorationAmino;
+    fromAminoMsg(object: MemberActionRestorationAminoMsg): MemberActionRestoration;
+    fromProtoMsg(message: MemberActionRestorationProtoMsg): MemberActionRestoration;
+    toProto(message: MemberActionRestoration): Uint8Array;
+    toProtoMsg(message: MemberActionRestoration): MemberActionRestorationProtoMsg;
+};

package/sparkdream/rep/v1/member_report.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReporterBondEntry = exports.MemberReport = void 0;
+exports.MemberActionRestoration = exports.MemberActionRestoration_ReputationEntry = exports.ReporterBondEntry = exports.MemberReport = void 0;
 const binary_1 = require("../../../binary");
 function createBaseMemberReport() {
     return {
@@ -15,7 +15,9 @@ function createBaseMemberReport() {
         reporters: [],
         evidencePostIds: [],
         defensePostIds: [],
-        reporterBonds: []
+        reporterBonds: [],
+        resolvedAction: 0,
+        resolvedAt: BigInt(0)
     };
 }
 /**
@@ -67,6 +69,12 @@ exports.MemberReport = {
         for (const v of message.reporterBonds) {
             exports.ReporterBondEntry.encode(v, writer.uint32(98).fork()).ldelim();
         }
+        if (message.resolvedAction !== 0) {
+            writer.uint32(104).int32(message.resolvedAction);
+        }
+        if (message.resolvedAt !== BigInt(0)) {
+            writer.uint32(112).int64(message.resolvedAt);
+        }
         return writer;
     },
     decode(input, length) {
@@ -128,6 +136,12 @@ exports.MemberReport = {
                 case 12:
                     message.reporterBonds.push(exports.ReporterBondEntry.decode(reader, reader.uint32()));
                     break;
+                case 13:
+                    message.resolvedAction = reader.int32();
+                    break;
+                case 14:
+                    message.resolvedAt = reader.int64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -149,6 +163,8 @@ exports.MemberReport = {
         message.evidencePostIds = object.evidencePostIds?.map(e => BigInt(e.toString())) || [];
         message.defensePostIds = object.defensePostIds?.map(e => BigInt(e.toString())) || [];
         message.reporterBonds = object.reporterBonds?.map(e => exports.ReporterBondEntry.fromPartial(e)) || [];
+        message.resolvedAction = object.resolvedAction ?? 0;
+        message.resolvedAt = object.resolvedAt !== undefined && object.resolvedAt !== null ? BigInt(object.resolvedAt.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -181,6 +197,12 @@ exports.MemberReport = {
         message.evidencePostIds = object.evidence_post_ids?.map(e => BigInt(e)) || [];
         message.defensePostIds = object.defense_post_ids?.map(e => BigInt(e)) || [];
         message.reporterBonds = object.reporter_bonds?.map(e => exports.ReporterBondEntry.fromAmino(e)) || [];
+        if (object.resolved_action !== undefined && object.resolved_action !== null) {
+            message.resolvedAction = object.resolved_action;
+        }
+        if (object.resolved_at !== undefined && object.resolved_at !== null) {
+            message.resolvedAt = BigInt(object.resolved_at);
+        }
         return message;
     },
     toAmino(message) {
@@ -217,6 +239,8 @@ exports.MemberReport = {
         else {
             obj.reporter_bonds = message.reporterBonds;
         }
+        obj.resolved_action = message.resolvedAction === 0 ? undefined : message.resolvedAction;
+        obj.resolved_at = message.resolvedAt !== BigInt(0) ? message.resolvedAt?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {
@@ -317,3 +341,313 @@ exports.ReporterBondEntry = {
         };
     }
 };
+function createBaseMemberActionRestoration_ReputationEntry() {
+    return {
+        key: "",
+        value: ""
+    };
+}
+/**
+ * @name MemberActionRestoration_ReputationEntry
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.undefined
+ */
+exports.MemberActionRestoration_ReputationEntry = {
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        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 = createBaseMemberActionRestoration_ReputationEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMemberActionRestoration_ReputationEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMemberActionRestoration_ReputationEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = object.key;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key === "" ? undefined : message.key;
+        obj.value = message.value === "" ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MemberActionRestoration_ReputationEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MemberActionRestoration_ReputationEntry.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MemberActionRestoration_ReputationEntry.encode(message).finish();
+    }
+};
+function createBaseMemberActionRestoration() {
+    return {
+        member: "",
+        action: 0,
+        resolvedAt: BigInt(0),
+        season: BigInt(0),
+        warningId: BigInt(0),
+        reputation: {},
+        priorStatus: 0,
+        priorTrustLevel: 0,
+        priorInvitationCredits: 0,
+        burnedDream: "",
+        zeroedCount: 0,
+        appealed: false,
+        appealId: BigInt(0)
+    };
+}
+/**
+ * MemberActionRestoration is what an OVERTURNED member-action appeal needs to
+ * undo the action MsgResolveMemberReport applied. Written at resolution, keyed
+ * by the member's canonical address (re-keyed by a migration), and deleted when
+ * the appeal reaches any terminal outcome or the filing window closes with no
+ * appeal, so at most one exists per member and only while the action is
+ * appealable.
+ * @name MemberActionRestoration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MemberActionRestoration
+ */
+exports.MemberActionRestoration = {
+    typeUrl: "/sparkdream.rep.v1.MemberActionRestoration",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.member !== "") {
+            writer.uint32(10).string(message.member);
+        }
+        if (message.action !== 0) {
+            writer.uint32(16).int32(message.action);
+        }
+        if (message.resolvedAt !== BigInt(0)) {
+            writer.uint32(24).int64(message.resolvedAt);
+        }
+        if (message.season !== BigInt(0)) {
+            writer.uint32(32).int64(message.season);
+        }
+        if (message.warningId !== BigInt(0)) {
+            writer.uint32(40).uint64(message.warningId);
+        }
+        Object.entries(message.reputation).forEach(([key, value]) => {
+            exports.MemberActionRestoration_ReputationEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(50).fork()).ldelim();
+        });
+        if (message.priorStatus !== 0) {
+            writer.uint32(56).int32(message.priorStatus);
+        }
+        if (message.priorTrustLevel !== 0) {
+            writer.uint32(64).int32(message.priorTrustLevel);
+        }
+        if (message.priorInvitationCredits !== 0) {
+            writer.uint32(72).uint32(message.priorInvitationCredits);
+        }
+        if (message.burnedDream !== "") {
+            writer.uint32(82).string(message.burnedDream);
+        }
+        if (message.zeroedCount !== 0) {
+            writer.uint32(88).uint32(message.zeroedCount);
+        }
+        if (message.appealed === true) {
+            writer.uint32(96).bool(message.appealed);
+        }
+        if (message.appealId !== BigInt(0)) {
+            writer.uint32(104).uint64(message.appealId);
+        }
+        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 = createBaseMemberActionRestoration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.member = reader.string();
+                    break;
+                case 2:
+                    message.action = reader.int32();
+                    break;
+                case 3:
+                    message.resolvedAt = reader.int64();
+                    break;
+                case 4:
+                    message.season = reader.int64();
+                    break;
+                case 5:
+                    message.warningId = reader.uint64();
+                    break;
+                case 6:
+                    const entry6 = exports.MemberActionRestoration_ReputationEntry.decode(reader, reader.uint32());
+                    if (entry6.value !== undefined) {
+                        message.reputation[entry6.key] = entry6.value;
+                    }
+                    break;
+                case 7:
+                    message.priorStatus = reader.int32();
+                    break;
+                case 8:
+                    message.priorTrustLevel = reader.int32();
+                    break;
+                case 9:
+                    message.priorInvitationCredits = reader.uint32();
+                    break;
+                case 10:
+                    message.burnedDream = reader.string();
+                    break;
+                case 11:
+                    message.zeroedCount = reader.uint32();
+                    break;
+                case 12:
+                    message.appealed = reader.bool();
+                    break;
+                case 13:
+                    message.appealId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMemberActionRestoration();
+        message.member = object.member ?? "";
+        message.action = object.action ?? 0;
+        message.resolvedAt = object.resolvedAt !== undefined && object.resolvedAt !== null ? BigInt(object.resolvedAt.toString()) : BigInt(0);
+        message.season = object.season !== undefined && object.season !== null ? BigInt(object.season.toString()) : BigInt(0);
+        message.warningId = object.warningId !== undefined && object.warningId !== null ? BigInt(object.warningId.toString()) : BigInt(0);
+        message.reputation = Object.entries(object.reputation ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        message.priorStatus = object.priorStatus ?? 0;
+        message.priorTrustLevel = object.priorTrustLevel ?? 0;
+        message.priorInvitationCredits = object.priorInvitationCredits ?? 0;
+        message.burnedDream = object.burnedDream ?? "";
+        message.zeroedCount = object.zeroedCount ?? 0;
+        message.appealed = object.appealed ?? false;
+        message.appealId = object.appealId !== undefined && object.appealId !== null ? BigInt(object.appealId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMemberActionRestoration();
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.action !== undefined && object.action !== null) {
+            message.action = object.action;
+        }
+        if (object.resolved_at !== undefined && object.resolved_at !== null) {
+            message.resolvedAt = BigInt(object.resolved_at);
+        }
+        if (object.season !== undefined && object.season !== null) {
+            message.season = BigInt(object.season);
+        }
+        if (object.warning_id !== undefined && object.warning_id !== null) {
+            message.warningId = BigInt(object.warning_id);
+        }
+        message.reputation = Object.entries(object.reputation ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        if (object.prior_status !== undefined && object.prior_status !== null) {
+            message.priorStatus = object.prior_status;
+        }
+        if (object.prior_trust_level !== undefined && object.prior_trust_level !== null) {
+            message.priorTrustLevel = object.prior_trust_level;
+        }
+        if (object.prior_invitation_credits !== undefined && object.prior_invitation_credits !== null) {
+            message.priorInvitationCredits = object.prior_invitation_credits;
+        }
+        if (object.burned_dream !== undefined && object.burned_dream !== null) {
+            message.burnedDream = object.burned_dream;
+        }
+        if (object.zeroed_count !== undefined && object.zeroed_count !== null) {
+            message.zeroedCount = object.zeroed_count;
+        }
+        if (object.appealed !== undefined && object.appealed !== null) {
+            message.appealed = object.appealed;
+        }
+        if (object.appeal_id !== undefined && object.appeal_id !== null) {
+            message.appealId = BigInt(object.appeal_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.action = message.action === 0 ? undefined : message.action;
+        obj.resolved_at = message.resolvedAt !== BigInt(0) ? message.resolvedAt?.toString() : undefined;
+        obj.season = message.season !== BigInt(0) ? message.season?.toString() : undefined;
+        obj.warning_id = message.warningId !== BigInt(0) ? message.warningId?.toString() : undefined;
+        obj.reputation = {};
+        if (message.reputation) {
+            Object.entries(message.reputation).forEach(([k, v]) => {
+                obj.reputation[k] = v;
+            });
+        }
+        obj.prior_status = message.priorStatus === 0 ? undefined : message.priorStatus;
+        obj.prior_trust_level = message.priorTrustLevel === 0 ? undefined : message.priorTrustLevel;
+        obj.prior_invitation_credits = message.priorInvitationCredits === 0 ? undefined : message.priorInvitationCredits;
+        obj.burned_dream = message.burnedDream === "" ? undefined : message.burnedDream;
+        obj.zeroed_count = message.zeroedCount === 0 ? undefined : message.zeroedCount;
+        obj.appealed = message.appealed === false ? undefined : message.appealed;
+        obj.appeal_id = message.appealId !== BigInt(0) ? message.appealId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MemberActionRestoration.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MemberActionRestoration.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MemberActionRestoration.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MemberActionRestoration",
+            value: exports.MemberActionRestoration.encode(message).finish()
+        };
+    }
+};

package/sparkdream/rep/v1/migration.d.ts

@@ -45,7 +45,8 @@ export declare enum MigrationStatus {
     MIGRATION_STATUS_ACCEPTED = 2,
     /**
      * MIGRATION_STATUS_OBJECTED - OBJECTED: (COUNCIL path) the old address objected during the delay and
-     * a jury review decides. The queue entry is removed until the verdict.
+     * a jury review decides. The queue entry is removed until the verdict. An
+     * inconclusive jury escalates the objection to x/gov (escalated_until).
      */
     MIGRATION_STATUS_OBJECTED = 3,
     /** MIGRATION_STATUS_FINALIZED - FINALIZED: the identity moved; the old address is a tombstone. */
@@ -119,6 +120,22 @@ export interface MemberMigration {
      * finalized_at is the block time of finalization (0 until then).
      */
     finalizedAt: bigint;
+    /**
+     * accept_by is the block time by which the new address must accept
+     * (requested_at + migration_accept_window at request time). Stored so the
+     * accept-expiry queue key never drifts when the param changes.
+     */
+    acceptBy: bigint;
+    /**
+     * escalated_until is set (COUNCIL path) when the objection jury reached no
+     * verdict (INCONCLUSIVE, including a jury that could not be seated). The
+     * objection is escalated to x/gov: the migration stays OBJECTED and the
+     * bond stays locked until governance cancels the migration (objection
+     * upheld, bond refunded) or re-forces it (objection rejected, bond paid to
+     * to_address). If governance has not decided by this block time the
+     * objection is rejected. 0 when not escalated.
+     */
+    escalatedUntil: bigint;
 }
 export interface MemberMigrationProtoMsg {
     typeUrl: "/sparkdream.rep.v1.MemberMigration";
@@ -176,6 +193,22 @@ export interface MemberMigrationAmino {
      * finalized_at is the block time of finalization (0 until then).
      */
     finalized_at?: string;
+    /**
+     * accept_by is the block time by which the new address must accept
+     * (requested_at + migration_accept_window at request time). Stored so the
+     * accept-expiry queue key never drifts when the param changes.
+     */
+    accept_by?: string;
+    /**
+     * escalated_until is set (COUNCIL path) when the objection jury reached no
+     * verdict (INCONCLUSIVE, including a jury that could not be seated). The
+     * objection is escalated to x/gov: the migration stays OBJECTED and the
+     * bond stays locked until governance cancels the migration (objection
+     * upheld, bond refunded) or re-forces it (objection rejected, bond paid to
+     * to_address). If governance has not decided by this block time the
+     * objection is rejected. 0 when not escalated.
+     */
+    escalated_until?: string;
 }
 export interface MemberMigrationAminoMsg {
     type: "/sparkdream.rep.v1.MemberMigration";