@sparkdreamnft/sparkdreamjs 0.0.34 → 0.0.36

package/esm/sparkdream/rep/v1/initiative.js

@@ -1,4 +1,5 @@
 //@ts-nocheck
+import { VerificationCriteria } from "./acceptance_criteria";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { Decimal } from "@interchainjs/math";
 export var InitiativeTier;
@@ -204,6 +205,65 @@ export function initiativeStatusToJSON(object) {
             return "UNRECOGNIZED";
     }
 }
+/**
+ * How an escalated review round was resolved by the Operations Committee.
+ *
+ * PASSED is also what committee *inaction* resolves to: silence must never wedge
+ * an initiative, and silence must never mint.
+ */
+export var ReviewEscalation;
+(function (ReviewEscalation) {
+    ReviewEscalation[ReviewEscalation["REVIEW_ESCALATION_NONE"] = 0] = "REVIEW_ESCALATION_NONE";
+    /**
+     * REVIEW_ESCALATION_APPROVED - Committee satisfied the reviewer gate itself. Writes no RoleActivity — the
+     * committee holds no bond and carries no accuracy record.
+     */
+    ReviewEscalation[ReviewEscalation["REVIEW_ESCALATION_APPROVED"] = 1] = "REVIEW_ESCALATION_APPROVED";
+    /** REVIEW_ESCALATION_REJECTED - Committee rejected; same effect as a reviewer rejection. */
+    ReviewEscalation[ReviewEscalation["REVIEW_ESCALATION_REJECTED"] = 2] = "REVIEW_ESCALATION_REJECTED";
+    /**
+     * REVIEW_ESCALATION_PASSED - Committee declined to substitute its judgement. The initiative proceeds on
+     * conviction alone; the challenge window still runs.
+     */
+    ReviewEscalation[ReviewEscalation["REVIEW_ESCALATION_PASSED"] = 3] = "REVIEW_ESCALATION_PASSED";
+    ReviewEscalation[ReviewEscalation["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ReviewEscalation || (ReviewEscalation = {}));
+export const ReviewEscalationAmino = ReviewEscalation;
+export function reviewEscalationFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "REVIEW_ESCALATION_NONE":
+            return ReviewEscalation.REVIEW_ESCALATION_NONE;
+        case 1:
+        case "REVIEW_ESCALATION_APPROVED":
+            return ReviewEscalation.REVIEW_ESCALATION_APPROVED;
+        case 2:
+        case "REVIEW_ESCALATION_REJECTED":
+            return ReviewEscalation.REVIEW_ESCALATION_REJECTED;
+        case 3:
+        case "REVIEW_ESCALATION_PASSED":
+            return ReviewEscalation.REVIEW_ESCALATION_PASSED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ReviewEscalation.UNRECOGNIZED;
+    }
+}
+export function reviewEscalationToJSON(object) {
+    switch (object) {
+        case ReviewEscalation.REVIEW_ESCALATION_NONE:
+            return "REVIEW_ESCALATION_NONE";
+        case ReviewEscalation.REVIEW_ESCALATION_APPROVED:
+            return "REVIEW_ESCALATION_APPROVED";
+        case ReviewEscalation.REVIEW_ESCALATION_REJECTED:
+            return "REVIEW_ESCALATION_REJECTED";
+        case ReviewEscalation.REVIEW_ESCALATION_PASSED:
+            return "REVIEW_ESCALATION_PASSED";
+        case ReviewEscalation.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
 function createBaseInitiative() {
     return {
         id: BigInt(0),
@@ -213,7 +273,6 @@ function createBaseInitiative() {
         tags: [],
         tier: 0,
         category: 0,
-        templateId: "",
         budget: "",
         assignee: "",
         apprentice: "",
@@ -231,7 +290,13 @@ function createBaseInitiative() {
         createdAt: BigInt(0),
         completedAt: BigInt(0),
         propagatedConviction: "",
-        selfAssignBond: ""
+        selfAssignBond: "",
+        acceptanceCriteria: [],
+        reviewRound: 0,
+        reviewDeadline: BigInt(0),
+        reviewEscalation: 0,
+        creator: "",
+        requiredVerifiers: 0
     };
 }
 /**
@@ -264,62 +329,77 @@ export const Initiative = {
         if (message.category !== 0) {
             writer.uint32(56).int32(message.category);
         }
-        if (message.templateId !== "") {
-            writer.uint32(66).string(message.templateId);
-        }
         if (message.budget !== "") {
-            writer.uint32(74).string(message.budget);
+            writer.uint32(66).string(message.budget);
         }
         if (message.assignee !== "") {
-            writer.uint32(82).string(message.assignee);
+            writer.uint32(74).string(message.assignee);
         }
         if (message.apprentice !== "") {
-            writer.uint32(90).string(message.apprentice);
+            writer.uint32(82).string(message.apprentice);
         }
         if (message.assignedAt !== BigInt(0)) {
-            writer.uint32(96).int64(message.assignedAt);
+            writer.uint32(88).int64(message.assignedAt);
         }
         if (message.deliverableUri !== "") {
-            writer.uint32(106).string(message.deliverableUri);
+            writer.uint32(98).string(message.deliverableUri);
         }
         if (message.submittedAt !== BigInt(0)) {
-            writer.uint32(112).int64(message.submittedAt);
+            writer.uint32(104).int64(message.submittedAt);
         }
         if (message.requiredConviction !== "") {
-            writer.uint32(122).string(Decimal.fromUserInput(message.requiredConviction, 18).atomics);
+            writer.uint32(114).string(Decimal.fromUserInput(message.requiredConviction, 18).atomics);
         }
         if (message.currentConviction !== "") {
-            writer.uint32(130).string(Decimal.fromUserInput(message.currentConviction, 18).atomics);
+            writer.uint32(122).string(Decimal.fromUserInput(message.currentConviction, 18).atomics);
         }
         if (message.externalConviction !== "") {
-            writer.uint32(138).string(Decimal.fromUserInput(message.externalConviction, 18).atomics);
+            writer.uint32(130).string(Decimal.fromUserInput(message.externalConviction, 18).atomics);
         }
         if (message.convictionLastUpdated !== BigInt(0)) {
-            writer.uint32(144).int64(message.convictionLastUpdated);
+            writer.uint32(136).int64(message.convictionLastUpdated);
         }
         if (message.reviewPeriodEnd !== BigInt(0)) {
-            writer.uint32(152).int64(message.reviewPeriodEnd);
+            writer.uint32(144).int64(message.reviewPeriodEnd);
         }
         if (message.challengePeriodEnd !== BigInt(0)) {
-            writer.uint32(160).int64(message.challengePeriodEnd);
+            writer.uint32(152).int64(message.challengePeriodEnd);
         }
         for (const v of message.approvals) {
-            writer.uint32(170).string(v);
+            writer.uint32(162).string(v);
         }
         if (message.status !== 0) {
-            writer.uint32(176).int32(message.status);
+            writer.uint32(168).int32(message.status);
         }
         if (message.createdAt !== BigInt(0)) {
-            writer.uint32(184).int64(message.createdAt);
+            writer.uint32(176).int64(message.createdAt);
         }
         if (message.completedAt !== BigInt(0)) {
-            writer.uint32(192).int64(message.completedAt);
+            writer.uint32(184).int64(message.completedAt);
         }
         if (message.propagatedConviction !== "") {
-            writer.uint32(202).string(Decimal.fromUserInput(message.propagatedConviction, 18).atomics);
+            writer.uint32(194).string(Decimal.fromUserInput(message.propagatedConviction, 18).atomics);
         }
         if (message.selfAssignBond !== "") {
-            writer.uint32(210).string(message.selfAssignBond);
+            writer.uint32(202).string(message.selfAssignBond);
+        }
+        for (const v of message.acceptanceCriteria) {
+            VerificationCriteria.encode(v, writer.uint32(218).fork()).ldelim();
+        }
+        if (message.reviewRound !== 0) {
+            writer.uint32(224).uint32(message.reviewRound);
+        }
+        if (message.reviewDeadline !== BigInt(0)) {
+            writer.uint32(232).int64(message.reviewDeadline);
+        }
+        if (message.reviewEscalation !== 0) {
+            writer.uint32(240).int32(message.reviewEscalation);
+        }
+        if (message.creator !== "") {
+            writer.uint32(210).string(message.creator);
+        }
+        if (message.requiredVerifiers !== 0) {
+            writer.uint32(248).uint32(message.requiredVerifiers);
         }
         return writer;
     },
@@ -352,61 +432,76 @@ export const Initiative = {
                     message.category = reader.int32();
                     break;
                 case 8:
-                    message.templateId = reader.string();
+                    message.budget = reader.string();
                     break;
                 case 9:
-                    message.budget = reader.string();
+                    message.assignee = reader.string();
                     break;
                 case 10:
-                    message.assignee = reader.string();
+                    message.apprentice = reader.string();
                     break;
                 case 11:
-                    message.apprentice = reader.string();
+                    message.assignedAt = reader.int64();
                     break;
                 case 12:
-                    message.assignedAt = reader.int64();
+                    message.deliverableUri = reader.string();
                     break;
                 case 13:
-                    message.deliverableUri = reader.string();
+                    message.submittedAt = reader.int64();
                     break;
                 case 14:
-                    message.submittedAt = reader.int64();
+                    message.requiredConviction = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 15:
-                    message.requiredConviction = Decimal.fromAtomics(reader.string(), 18).toString();
+                    message.currentConviction = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 16:
-                    message.currentConviction = Decimal.fromAtomics(reader.string(), 18).toString();
+                    message.externalConviction = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 17:
-                    message.externalConviction = Decimal.fromAtomics(reader.string(), 18).toString();
+                    message.convictionLastUpdated = reader.int64();
                     break;
                 case 18:
-                    message.convictionLastUpdated = reader.int64();
+                    message.reviewPeriodEnd = reader.int64();
                     break;
                 case 19:
-                    message.reviewPeriodEnd = reader.int64();
+                    message.challengePeriodEnd = reader.int64();
                     break;
                 case 20:
-                    message.challengePeriodEnd = reader.int64();
+                    message.approvals.push(reader.string());
                     break;
                 case 21:
-                    message.approvals.push(reader.string());
+                    message.status = reader.int32();
                     break;
                 case 22:
-                    message.status = reader.int32();
+                    message.createdAt = reader.int64();
                     break;
                 case 23:
-                    message.createdAt = reader.int64();
+                    message.completedAt = reader.int64();
                     break;
                 case 24:
-                    message.completedAt = reader.int64();
+                    message.propagatedConviction = Decimal.fromAtomics(reader.string(), 18).toString();
                     break;
                 case 25:
-                    message.propagatedConviction = Decimal.fromAtomics(reader.string(), 18).toString();
+                    message.selfAssignBond = reader.string();
+                    break;
+                case 27:
+                    message.acceptanceCriteria.push(VerificationCriteria.decode(reader, reader.uint32()));
+                    break;
+                case 28:
+                    message.reviewRound = reader.uint32();
+                    break;
+                case 29:
+                    message.reviewDeadline = reader.int64();
+                    break;
+                case 30:
+                    message.reviewEscalation = reader.int32();
                     break;
                 case 26:
-                    message.selfAssignBond = reader.string();
+                    message.creator = reader.string();
+                    break;
+                case 31:
+                    message.requiredVerifiers = reader.uint32();
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -424,7 +519,6 @@ export const Initiative = {
         message.tags = object.tags?.map(e => e) || [];
         message.tier = object.tier ?? 0;
         message.category = object.category ?? 0;
-        message.templateId = object.templateId ?? "";
         message.budget = object.budget ?? "";
         message.assignee = object.assignee ?? "";
         message.apprentice = object.apprentice ?? "";
@@ -443,6 +537,12 @@ export const Initiative = {
         message.completedAt = object.completedAt !== undefined && object.completedAt !== null ? BigInt(object.completedAt.toString()) : BigInt(0);
         message.propagatedConviction = object.propagatedConviction ?? "";
         message.selfAssignBond = object.selfAssignBond ?? "";
+        message.acceptanceCriteria = object.acceptanceCriteria?.map(e => VerificationCriteria.fromPartial(e)) || [];
+        message.reviewRound = object.reviewRound ?? 0;
+        message.reviewDeadline = object.reviewDeadline !== undefined && object.reviewDeadline !== null ? BigInt(object.reviewDeadline.toString()) : BigInt(0);
+        message.reviewEscalation = object.reviewEscalation ?? 0;
+        message.creator = object.creator ?? "";
+        message.requiredVerifiers = object.requiredVerifiers ?? 0;
         return message;
     },
     fromAmino(object) {
@@ -466,9 +566,6 @@ export const Initiative = {
         if (object.category !== undefined && object.category !== null) {
             message.category = object.category;
         }
-        if (object.template_id !== undefined && object.template_id !== null) {
-            message.templateId = object.template_id;
-        }
         if (object.budget !== undefined && object.budget !== null) {
             message.budget = object.budget;
         }
@@ -521,6 +618,22 @@ export const Initiative = {
         if (object.self_assign_bond !== undefined && object.self_assign_bond !== null) {
             message.selfAssignBond = object.self_assign_bond;
         }
+        message.acceptanceCriteria = object.acceptance_criteria?.map(e => VerificationCriteria.fromAmino(e)) || [];
+        if (object.review_round !== undefined && object.review_round !== null) {
+            message.reviewRound = object.review_round;
+        }
+        if (object.review_deadline !== undefined && object.review_deadline !== null) {
+            message.reviewDeadline = BigInt(object.review_deadline);
+        }
+        if (object.review_escalation !== undefined && object.review_escalation !== null) {
+            message.reviewEscalation = object.review_escalation;
+        }
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        if (object.required_verifiers !== undefined && object.required_verifiers !== null) {
+            message.requiredVerifiers = object.required_verifiers;
+        }
         return message;
     },
     toAmino(message) {
@@ -537,7 +650,6 @@ export const Initiative = {
         }
         obj.tier = message.tier === 0 ? undefined : message.tier;
         obj.category = message.category === 0 ? undefined : message.category;
-        obj.template_id = message.templateId === "" ? undefined : message.templateId;
         obj.budget = message.budget === "" ? undefined : message.budget;
         obj.assignee = message.assignee === "" ? undefined : message.assignee;
         obj.apprentice = message.apprentice === "" ? undefined : message.apprentice;
@@ -561,6 +673,17 @@ export const Initiative = {
         obj.completed_at = message.completedAt !== BigInt(0) ? message.completedAt?.toString() : undefined;
         obj.propagated_conviction = message.propagatedConviction === "" ? undefined : message.propagatedConviction;
         obj.self_assign_bond = message.selfAssignBond === "" ? undefined : message.selfAssignBond;
+        if (message.acceptanceCriteria) {
+            obj.acceptance_criteria = message.acceptanceCriteria.map(e => e ? VerificationCriteria.toAmino(e) : undefined);
+        }
+        else {
+            obj.acceptance_criteria = message.acceptanceCriteria;
+        }
+        obj.review_round = message.reviewRound === 0 ? undefined : message.reviewRound;
+        obj.review_deadline = message.reviewDeadline !== BigInt(0) ? message.reviewDeadline?.toString() : undefined;
+        obj.review_escalation = message.reviewEscalation === 0 ? undefined : message.reviewEscalation;
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.required_verifiers = message.requiredVerifiers === 0 ? undefined : message.requiredVerifiers;
         return obj;
     },
     fromAminoMsg(object) {

package/esm/sparkdream/rep/v1/initiative_review.js

@@ -0,0 +1,179 @@
+//@ts-nocheck
+import { CriteriaVote } from "./jury_review";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseInitiativeReview() {
+    return {
+        initiativeId: BigInt(0),
+        round: 0,
+        reviewer: "",
+        approved: false,
+        criteriaVotes: [],
+        comments: "",
+        createdAt: BigInt(0),
+        bondReserved: "",
+        settled: false
+    };
+}
+/**
+ * One bonded reviewer's verdict on a round of submitted work.
+ *
+ * Keyed by (initiative_id, round, reviewer): a rejection sends the initiative
+ * back to ASSIGNED for the assignee to fix and resubmit, and each resubmission
+ * opens a new round, so the same reviewer may legitimately file again on the
+ * same initiative. Rounds are bounded by max_review_rounds.
+ *
+ * Reviewers are paid per verdict filed, never per approval — the whole point of
+ * the role is that judging pays and the outcome does not.
+ * @name InitiativeReview
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.InitiativeReview
+ */
+export const InitiativeReview = {
+    typeUrl: "/sparkdream.rep.v1.InitiativeReview",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.initiativeId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.initiativeId);
+        }
+        if (message.round !== 0) {
+            writer.uint32(16).uint32(message.round);
+        }
+        if (message.reviewer !== "") {
+            writer.uint32(26).string(message.reviewer);
+        }
+        if (message.approved === true) {
+            writer.uint32(32).bool(message.approved);
+        }
+        for (const v of message.criteriaVotes) {
+            CriteriaVote.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.comments !== "") {
+            writer.uint32(50).string(message.comments);
+        }
+        if (message.createdAt !== BigInt(0)) {
+            writer.uint32(56).int64(message.createdAt);
+        }
+        if (message.bondReserved !== "") {
+            writer.uint32(66).string(message.bondReserved);
+        }
+        if (message.settled === true) {
+            writer.uint32(72).bool(message.settled);
+        }
+        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 = createBaseInitiativeReview();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.initiativeId = reader.uint64();
+                    break;
+                case 2:
+                    message.round = reader.uint32();
+                    break;
+                case 3:
+                    message.reviewer = reader.string();
+                    break;
+                case 4:
+                    message.approved = reader.bool();
+                    break;
+                case 5:
+                    message.criteriaVotes.push(CriteriaVote.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.comments = reader.string();
+                    break;
+                case 7:
+                    message.createdAt = reader.int64();
+                    break;
+                case 8:
+                    message.bondReserved = reader.string();
+                    break;
+                case 9:
+                    message.settled = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseInitiativeReview();
+        message.initiativeId = object.initiativeId !== undefined && object.initiativeId !== null ? BigInt(object.initiativeId.toString()) : BigInt(0);
+        message.round = object.round ?? 0;
+        message.reviewer = object.reviewer ?? "";
+        message.approved = object.approved ?? false;
+        message.criteriaVotes = object.criteriaVotes?.map(e => CriteriaVote.fromPartial(e)) || [];
+        message.comments = object.comments ?? "";
+        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
+        message.bondReserved = object.bondReserved ?? "";
+        message.settled = object.settled ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseInitiativeReview();
+        if (object.initiative_id !== undefined && object.initiative_id !== null) {
+            message.initiativeId = BigInt(object.initiative_id);
+        }
+        if (object.round !== undefined && object.round !== null) {
+            message.round = object.round;
+        }
+        if (object.reviewer !== undefined && object.reviewer !== null) {
+            message.reviewer = object.reviewer;
+        }
+        if (object.approved !== undefined && object.approved !== null) {
+            message.approved = object.approved;
+        }
+        message.criteriaVotes = object.criteria_votes?.map(e => CriteriaVote.fromAmino(e)) || [];
+        if (object.comments !== undefined && object.comments !== null) {
+            message.comments = object.comments;
+        }
+        if (object.created_at !== undefined && object.created_at !== null) {
+            message.createdAt = BigInt(object.created_at);
+        }
+        if (object.bond_reserved !== undefined && object.bond_reserved !== null) {
+            message.bondReserved = object.bond_reserved;
+        }
+        if (object.settled !== undefined && object.settled !== null) {
+            message.settled = object.settled;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.initiative_id = message.initiativeId !== BigInt(0) ? message.initiativeId?.toString() : undefined;
+        obj.round = message.round === 0 ? undefined : message.round;
+        obj.reviewer = message.reviewer === "" ? undefined : message.reviewer;
+        obj.approved = message.approved === false ? undefined : message.approved;
+        if (message.criteriaVotes) {
+            obj.criteria_votes = message.criteriaVotes.map(e => e ? CriteriaVote.toAmino(e) : undefined);
+        }
+        else {
+            obj.criteria_votes = message.criteriaVotes;
+        }
+        obj.comments = message.comments === "" ? undefined : message.comments;
+        obj.created_at = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
+        obj.bond_reserved = message.bondReserved === "" ? undefined : message.bondReserved;
+        obj.settled = message.settled === false ? undefined : message.settled;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return InitiativeReview.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return InitiativeReview.decode(message.value);
+    },
+    toProto(message) {
+        return InitiativeReview.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.InitiativeReview",
+            value: InitiativeReview.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/rep/v1/jury_participation.js

@@ -7,11 +7,30 @@ function createBaseJuryParticipation() {
         totalVoted: BigInt(0),
         totalTimeouts: BigInt(0),
         lastAssignedAt: BigInt(0),
-        excluded: false
+        totalDeclined: BigInt(0),
+        totalAbandoned: BigInt(0)
     };
 }
 /**
- * JuryParticipation defines the JuryParticipation message.
+ * JuryParticipation is a juror's service record.
+ *
+ * Jurors are drawn by lot and paid a flat participation reward for voting.
+ * Ignoring a summons is **not** penalised: the adjudication terminal path
+ * resolves an inconclusive jury safely and the redraw sweep replaces an
+ * unanswered seat within the acceptance window, so what remains of a no-show is
+ * a few hours of delay in a week-long review. Pricing that would oblige every
+ * eligible member to monitor the chain for an event that reaches them roughly
+ * once a year, and under broad sortition non-response is the expected default
+ * of a population that never volunteered.
+ *
+ * This record instead feeds **selection weight**: a juror who never answers is
+ * drawn less often, never removed from the lot. Nobody loses eligibility, and an
+ * address can always earn its weight back — which an excluded one could not,
+ * since it would never be drawn again to demonstrate otherwise.
+ *
+ * The one penalised case is total_abandoned: accepting a summons and then
+ * letting it lapse. Accepting is voluntary and declining is free, so that is a
+ * broken commitment rather than an accident, and it is charged in reputation.
  * @name JuryParticipation
  * @package sparkdream.rep.v1
  * @see proto type: sparkdream.rep.v1.JuryParticipation
@@ -34,8 +53,11 @@ export const JuryParticipation = {
         if (message.lastAssignedAt !== BigInt(0)) {
             writer.uint32(40).int64(message.lastAssignedAt);
         }
-        if (message.excluded === true) {
-            writer.uint32(48).bool(message.excluded);
+        if (message.totalDeclined !== BigInt(0)) {
+            writer.uint32(48).uint64(message.totalDeclined);
+        }
+        if (message.totalAbandoned !== BigInt(0)) {
+            writer.uint32(56).uint64(message.totalAbandoned);
         }
         return writer;
     },
@@ -62,7 +84,10 @@ export const JuryParticipation = {
                     message.lastAssignedAt = reader.int64();
                     break;
                 case 6:
-                    message.excluded = reader.bool();
+                    message.totalDeclined = reader.uint64();
+                    break;
+                case 7:
+                    message.totalAbandoned = reader.uint64();
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -78,7 +103,8 @@ export const JuryParticipation = {
         message.totalVoted = object.totalVoted !== undefined && object.totalVoted !== null ? BigInt(object.totalVoted.toString()) : BigInt(0);
         message.totalTimeouts = object.totalTimeouts !== undefined && object.totalTimeouts !== null ? BigInt(object.totalTimeouts.toString()) : BigInt(0);
         message.lastAssignedAt = object.lastAssignedAt !== undefined && object.lastAssignedAt !== null ? BigInt(object.lastAssignedAt.toString()) : BigInt(0);
-        message.excluded = object.excluded ?? false;
+        message.totalDeclined = object.totalDeclined !== undefined && object.totalDeclined !== null ? BigInt(object.totalDeclined.toString()) : BigInt(0);
+        message.totalAbandoned = object.totalAbandoned !== undefined && object.totalAbandoned !== null ? BigInt(object.totalAbandoned.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -98,8 +124,11 @@ export const JuryParticipation = {
         if (object.last_assigned_at !== undefined && object.last_assigned_at !== null) {
             message.lastAssignedAt = BigInt(object.last_assigned_at);
         }
-        if (object.excluded !== undefined && object.excluded !== null) {
-            message.excluded = object.excluded;
+        if (object.total_declined !== undefined && object.total_declined !== null) {
+            message.totalDeclined = BigInt(object.total_declined);
+        }
+        if (object.total_abandoned !== undefined && object.total_abandoned !== null) {
+            message.totalAbandoned = BigInt(object.total_abandoned);
         }
         return message;
     },
@@ -110,7 +139,8 @@ export const JuryParticipation = {
         obj.total_voted = message.totalVoted !== BigInt(0) ? message.totalVoted?.toString() : undefined;
         obj.total_timeouts = message.totalTimeouts !== BigInt(0) ? message.totalTimeouts?.toString() : undefined;
         obj.last_assigned_at = message.lastAssignedAt !== BigInt(0) ? message.lastAssignedAt?.toString() : undefined;
-        obj.excluded = message.excluded === false ? undefined : message.excluded;
+        obj.total_declined = message.totalDeclined !== BigInt(0) ? message.totalDeclined?.toString() : undefined;
+        obj.total_abandoned = message.totalAbandoned !== BigInt(0) ? message.totalAbandoned?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {