@sparkdreamnft/sparkdreamjs 0.0.43 → 0.0.45

package/esm/sparkdream/shield/v1/types.js

@@ -80,6 +80,47 @@ export function nullifierScopeTypeToJSON(object) {
             return "UNRECOGNIZED";
     }
 }
+/** NullifierMode controls what an operation's nullifier proves. */
+export var NullifierMode;
+(function (NullifierMode) {
+    /** NULLIFIER_MODE_CONSUME - The nullifier is consumed: each (member, scope) acts once. */
+    NullifierMode[NullifierMode["NULLIFIER_MODE_CONSUME"] = 0] = "NULLIFIER_MODE_CONSUME";
+    /**
+     * NULLIFIER_MODE_OWNERSHIP - The nullifier proves ownership of anonymously created content and is
+     * reused: the target module's ShieldOwnershipResolver supplies the owner's
+     * domain, scope and tag (the creation nullifier), the proof must reproduce
+     * the tag, and the owner's sequence (bound into the message hash) stops
+     * replays. Immediate mode only.
+     */
+    NullifierMode[NullifierMode["NULLIFIER_MODE_OWNERSHIP"] = 1] = "NULLIFIER_MODE_OWNERSHIP";
+    NullifierMode[NullifierMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(NullifierMode || (NullifierMode = {}));
+export const NullifierModeAmino = NullifierMode;
+export function nullifierModeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "NULLIFIER_MODE_CONSUME":
+            return NullifierMode.NULLIFIER_MODE_CONSUME;
+        case 1:
+        case "NULLIFIER_MODE_OWNERSHIP":
+            return NullifierMode.NULLIFIER_MODE_OWNERSHIP;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return NullifierMode.UNRECOGNIZED;
+    }
+}
+export function nullifierModeToJSON(object) {
+    switch (object) {
+        case NullifierMode.NULLIFIER_MODE_CONSUME:
+            return "NULLIFIER_MODE_CONSUME";
+        case NullifierMode.NULLIFIER_MODE_OWNERSHIP:
+            return "NULLIFIER_MODE_OWNERSHIP";
+        case NullifierMode.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
 /** ShieldBatchMode controls which execution modes an operation supports. */
 export var ShieldBatchMode;
 (function (ShieldBatchMode) {
@@ -164,8 +205,19 @@ export var DKGPhase;
     DKGPhase[DKGPhase["DKG_PHASE_REGISTERING"] = 1] = "DKG_PHASE_REGISTERING";
     /** DKG_PHASE_CONTRIBUTING - Key registration closed; accepting Feldman DKG contributions */
     DKGPhase[DKGPhase["DKG_PHASE_CONTRIBUTING"] = 2] = "DKG_PHASE_CONTRIBUTING";
-    /** DKG_PHASE_ACTIVE - DKG complete, master key available, encrypted batch enabled */
+    /** DKG_PHASE_ACTIVE - DKG complete, master key available */
     DKGPhase[DKGPhase["DKG_PHASE_ACTIVE"] = 3] = "DKG_PHASE_ACTIVE";
+    /**
+     * DKG_PHASE_COMPLAINING - Contributions closed; validators report dealers whose evaluation for
+     * them is missing, undecryptable or inconsistent with the commitments
+     */
+    DKGPhase[DKGPhase["DKG_PHASE_COMPLAINING"] = 4] = "DKG_PHASE_COMPLAINING";
+    /**
+     * DKG_PHASE_JUSTIFYING - Complaints closed; accused dealers publish the disputed evaluations in
+     * clear. A dealer with an unjustified complaint at the deadline is
+     * disqualified from the key set.
+     */
+    DKGPhase[DKGPhase["DKG_PHASE_JUSTIFYING"] = 5] = "DKG_PHASE_JUSTIFYING";
     DKGPhase[DKGPhase["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(DKGPhase || (DKGPhase = {}));
 export const DKGPhaseAmino = DKGPhase;
@@ -183,6 +235,12 @@ export function dKGPhaseFromJSON(object) {
         case 3:
         case "DKG_PHASE_ACTIVE":
             return DKGPhase.DKG_PHASE_ACTIVE;
+        case 4:
+        case "DKG_PHASE_COMPLAINING":
+            return DKGPhase.DKG_PHASE_COMPLAINING;
+        case 5:
+        case "DKG_PHASE_JUSTIFYING":
+            return DKGPhase.DKG_PHASE_JUSTIFYING;
         case -1:
         case "UNRECOGNIZED":
         default:
@@ -199,6 +257,10 @@ export function dKGPhaseToJSON(object) {
             return "DKG_PHASE_CONTRIBUTING";
         case DKGPhase.DKG_PHASE_ACTIVE:
             return "DKG_PHASE_ACTIVE";
+        case DKGPhase.DKG_PHASE_COMPLAINING:
+            return "DKG_PHASE_COMPLAINING";
+        case DKGPhase.DKG_PHASE_JUSTIFYING:
+            return "DKG_PHASE_JUSTIFYING";
         case DKGPhase.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";
@@ -213,7 +275,9 @@ function createBaseShieldedOpRegistration() {
         nullifierScopeType: 0,
         active: false,
         batchMode: 0,
-        scopeFieldPath: ""
+        scopeFieldPath: "",
+        nullifierMode: 0,
+        epochWindow: BigInt(0)
     };
 }
 /**
@@ -249,6 +313,12 @@ export const ShieldedOpRegistration = {
         if (message.scopeFieldPath !== "") {
             writer.uint32(66).string(message.scopeFieldPath);
         }
+        if (message.nullifierMode !== 0) {
+            writer.uint32(72).int32(message.nullifierMode);
+        }
+        if (message.epochWindow !== BigInt(0)) {
+            writer.uint32(80).uint64(message.epochWindow);
+        }
         return writer;
     },
     decode(input, length) {
@@ -282,6 +352,12 @@ export const ShieldedOpRegistration = {
                 case 8:
                     message.scopeFieldPath = reader.string();
                     break;
+                case 9:
+                    message.nullifierMode = reader.int32();
+                    break;
+                case 10:
+                    message.epochWindow = reader.uint64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -299,6 +375,8 @@ export const ShieldedOpRegistration = {
         message.active = object.active ?? false;
         message.batchMode = object.batchMode ?? 0;
         message.scopeFieldPath = object.scopeFieldPath ?? "";
+        message.nullifierMode = object.nullifierMode ?? 0;
+        message.epochWindow = object.epochWindow !== undefined && object.epochWindow !== null ? BigInt(object.epochWindow.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -327,6 +405,12 @@ export const ShieldedOpRegistration = {
         if (object.scope_field_path !== undefined && object.scope_field_path !== null) {
             message.scopeFieldPath = object.scope_field_path;
         }
+        if (object.nullifier_mode !== undefined && object.nullifier_mode !== null) {
+            message.nullifierMode = object.nullifier_mode;
+        }
+        if (object.epoch_window !== undefined && object.epoch_window !== null) {
+            message.epochWindow = BigInt(object.epoch_window);
+        }
         return message;
     },
     toAmino(message) {
@@ -339,6 +423,8 @@ export const ShieldedOpRegistration = {
         obj.active = message.active === false ? undefined : message.active;
         obj.batch_mode = message.batchMode === 0 ? undefined : message.batchMode;
         obj.scope_field_path = message.scopeFieldPath === "" ? undefined : message.scopeFieldPath;
+        obj.nullifier_mode = message.nullifierMode === 0 ? undefined : message.nullifierMode;
+        obj.epoch_window = message.epochWindow !== BigInt(0) ? message.epochWindow?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {
@@ -471,7 +557,7 @@ function createBaseDayFunding() {
 }
 /**
  * DayFunding tracks funding per day to enforce the daily cap.
- * Day is calculated as block_height / 14400 (at 6s/block = 1 day).
+ * Day is the UTC day of the block time (block_time / 86400).
  * @name DayFunding
  * @package sparkdream.shield.v1
  * @see proto type: sparkdream.shield.v1.DayFunding
@@ -549,17 +635,19 @@ function createBasePendingShieldedOp() {
     return {
         id: BigInt(0),
         targetEpoch: BigInt(0),
-        nullifier: new Uint8Array(),
+        submissionNullifier: new Uint8Array(),
         merkleRoot: new Uint8Array(),
         proofDomain: 0,
         minTrustLevel: 0,
         encryptedPayload: new Uint8Array(),
         submittedAtHeight: BigInt(0),
-        submittedAtEpoch: BigInt(0)
+        submittedAtEpoch: BigInt(0),
+        rateLimitNullifier: new Uint8Array()
     };
 }
 /**
- * PendingShieldedOp is stored in queue until the shield epoch boundary triggers batch execution.
+ * PendingShieldedOp is stored in queue until its epoch has closed, its batch was
+ * demanded and the epoch key exists; it then executes in that block.
  * @name PendingShieldedOp
  * @package sparkdream.shield.v1
  * @see proto type: sparkdream.shield.v1.PendingShieldedOp
@@ -573,8 +661,8 @@ export const PendingShieldedOp = {
         if (message.targetEpoch !== BigInt(0)) {
             writer.uint32(16).uint64(message.targetEpoch);
         }
-        if (message.nullifier.length !== 0) {
-            writer.uint32(26).bytes(message.nullifier);
+        if (message.submissionNullifier.length !== 0) {
+            writer.uint32(26).bytes(message.submissionNullifier);
         }
         if (message.merkleRoot.length !== 0) {
             writer.uint32(34).bytes(message.merkleRoot);
@@ -594,6 +682,9 @@ export const PendingShieldedOp = {
         if (message.submittedAtEpoch !== BigInt(0)) {
             writer.uint32(72).uint64(message.submittedAtEpoch);
         }
+        if (message.rateLimitNullifier.length !== 0) {
+            writer.uint32(82).bytes(message.rateLimitNullifier);
+        }
         return writer;
     },
     decode(input, length) {
@@ -610,7 +701,7 @@ export const PendingShieldedOp = {
                     message.targetEpoch = reader.uint64();
                     break;
                 case 3:
-                    message.nullifier = reader.bytes();
+                    message.submissionNullifier = reader.bytes();
                     break;
                 case 4:
                     message.merkleRoot = reader.bytes();
@@ -630,6 +721,9 @@ export const PendingShieldedOp = {
                 case 9:
                     message.submittedAtEpoch = reader.uint64();
                     break;
+                case 10:
+                    message.rateLimitNullifier = reader.bytes();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -641,13 +735,14 @@ export const PendingShieldedOp = {
         const message = createBasePendingShieldedOp();
         message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
         message.targetEpoch = object.targetEpoch !== undefined && object.targetEpoch !== null ? BigInt(object.targetEpoch.toString()) : BigInt(0);
-        message.nullifier = object.nullifier ?? new Uint8Array();
+        message.submissionNullifier = object.submissionNullifier ?? new Uint8Array();
         message.merkleRoot = object.merkleRoot ?? new Uint8Array();
         message.proofDomain = object.proofDomain ?? 0;
         message.minTrustLevel = object.minTrustLevel ?? 0;
         message.encryptedPayload = object.encryptedPayload ?? new Uint8Array();
         message.submittedAtHeight = object.submittedAtHeight !== undefined && object.submittedAtHeight !== null ? BigInt(object.submittedAtHeight.toString()) : BigInt(0);
         message.submittedAtEpoch = object.submittedAtEpoch !== undefined && object.submittedAtEpoch !== null ? BigInt(object.submittedAtEpoch.toString()) : BigInt(0);
+        message.rateLimitNullifier = object.rateLimitNullifier ?? new Uint8Array();
         return message;
     },
     fromAmino(object) {
@@ -658,8 +753,8 @@ export const PendingShieldedOp = {
         if (object.target_epoch !== undefined && object.target_epoch !== null) {
             message.targetEpoch = BigInt(object.target_epoch);
         }
-        if (object.nullifier !== undefined && object.nullifier !== null) {
-            message.nullifier = bytesFromBase64(object.nullifier);
+        if (object.submission_nullifier !== undefined && object.submission_nullifier !== null) {
+            message.submissionNullifier = bytesFromBase64(object.submission_nullifier);
         }
         if (object.merkle_root !== undefined && object.merkle_root !== null) {
             message.merkleRoot = bytesFromBase64(object.merkle_root);
@@ -679,19 +774,23 @@ export const PendingShieldedOp = {
         if (object.submitted_at_epoch !== undefined && object.submitted_at_epoch !== null) {
             message.submittedAtEpoch = BigInt(object.submitted_at_epoch);
         }
+        if (object.rate_limit_nullifier !== undefined && object.rate_limit_nullifier !== null) {
+            message.rateLimitNullifier = bytesFromBase64(object.rate_limit_nullifier);
+        }
         return message;
     },
     toAmino(message) {
         const obj = {};
         obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
         obj.target_epoch = message.targetEpoch !== BigInt(0) ? message.targetEpoch?.toString() : undefined;
-        obj.nullifier = message.nullifier ? base64FromBytes(message.nullifier) : undefined;
+        obj.submission_nullifier = message.submissionNullifier ? base64FromBytes(message.submissionNullifier) : undefined;
         obj.merkle_root = message.merkleRoot ? base64FromBytes(message.merkleRoot) : undefined;
         obj.proof_domain = message.proofDomain === 0 ? undefined : message.proofDomain;
         obj.min_trust_level = message.minTrustLevel === 0 ? undefined : message.minTrustLevel;
         obj.encrypted_payload = message.encryptedPayload ? base64FromBytes(message.encryptedPayload) : undefined;
         obj.submitted_at_height = message.submittedAtHeight !== BigInt(0) ? message.submittedAtHeight?.toString() : undefined;
         obj.submitted_at_epoch = message.submittedAtEpoch !== BigInt(0) ? message.submittedAtEpoch?.toString() : undefined;
+        obj.rate_limit_nullifier = message.rateLimitNullifier ? base64FromBytes(message.rateLimitNullifier) : undefined;
         return obj;
     },
     fromAminoMsg(object) {
@@ -995,7 +1094,8 @@ function createBaseTLEKeySet() {
         thresholdNumerator: BigInt(0),
         thresholdDenominator: BigInt(0),
         validatorShares: [],
-        createdAtHeight: BigInt(0)
+        createdAtHeight: BigInt(0),
+        masterPublicKeyG2: new Uint8Array()
     };
 }
 /**
@@ -1022,6 +1122,9 @@ export const TLEKeySet = {
         if (message.createdAtHeight !== BigInt(0)) {
             writer.uint32(40).int64(message.createdAtHeight);
         }
+        if (message.masterPublicKeyG2.length !== 0) {
+            writer.uint32(50).bytes(message.masterPublicKeyG2);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1046,6 +1149,9 @@ export const TLEKeySet = {
                 case 5:
                     message.createdAtHeight = reader.int64();
                     break;
+                case 6:
+                    message.masterPublicKeyG2 = reader.bytes();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1060,6 +1166,7 @@ export const TLEKeySet = {
         message.thresholdDenominator = object.thresholdDenominator !== undefined && object.thresholdDenominator !== null ? BigInt(object.thresholdDenominator.toString()) : BigInt(0);
         message.validatorShares = object.validatorShares?.map(e => TLEValidatorPublicShare.fromPartial(e)) || [];
         message.createdAtHeight = object.createdAtHeight !== undefined && object.createdAtHeight !== null ? BigInt(object.createdAtHeight.toString()) : BigInt(0);
+        message.masterPublicKeyG2 = object.masterPublicKeyG2 ?? new Uint8Array();
         return message;
     },
     fromAmino(object) {
@@ -1077,6 +1184,9 @@ export const TLEKeySet = {
         if (object.created_at_height !== undefined && object.created_at_height !== null) {
             message.createdAtHeight = BigInt(object.created_at_height);
         }
+        if (object.master_public_key_g2 !== undefined && object.master_public_key_g2 !== null) {
+            message.masterPublicKeyG2 = bytesFromBase64(object.master_public_key_g2);
+        }
         return message;
     },
     toAmino(message) {
@@ -1091,6 +1201,7 @@ export const TLEKeySet = {
             obj.validator_shares = message.validatorShares;
         }
         obj.created_at_height = message.createdAtHeight !== BigInt(0) ? message.createdAtHeight?.toString() : undefined;
+        obj.master_public_key_g2 = message.masterPublicKeyG2 ? base64FromBytes(message.masterPublicKeyG2) : undefined;
         return obj;
     },
     fromAminoMsg(object) {
@@ -1224,7 +1335,10 @@ function createBaseDKGState() {
         thresholdNumerator: BigInt(0),
         thresholdDenominator: BigInt(0),
         expectedValidators: [],
-        contributionsReceived: BigInt(0)
+        contributionsReceived: BigInt(0),
+        complaintDeadline: BigInt(0),
+        justificationDeadline: BigInt(0),
+        disqualifiedDealers: []
     };
 }
 /**
@@ -1263,6 +1377,15 @@ export const DKGState = {
         if (message.contributionsReceived !== BigInt(0)) {
             writer.uint32(72).uint64(message.contributionsReceived);
         }
+        if (message.complaintDeadline !== BigInt(0)) {
+            writer.uint32(80).int64(message.complaintDeadline);
+        }
+        if (message.justificationDeadline !== BigInt(0)) {
+            writer.uint32(88).int64(message.justificationDeadline);
+        }
+        for (const v of message.disqualifiedDealers) {
+            writer.uint32(98).string(v);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1299,6 +1422,15 @@ export const DKGState = {
                 case 9:
                     message.contributionsReceived = reader.uint64();
                     break;
+                case 10:
+                    message.complaintDeadline = reader.int64();
+                    break;
+                case 11:
+                    message.justificationDeadline = reader.int64();
+                    break;
+                case 12:
+                    message.disqualifiedDealers.push(reader.string());
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1317,6 +1449,9 @@ export const DKGState = {
         message.thresholdDenominator = object.thresholdDenominator !== undefined && object.thresholdDenominator !== null ? BigInt(object.thresholdDenominator.toString()) : BigInt(0);
         message.expectedValidators = object.expectedValidators?.map(e => e) || [];
         message.contributionsReceived = object.contributionsReceived !== undefined && object.contributionsReceived !== null ? BigInt(object.contributionsReceived.toString()) : BigInt(0);
+        message.complaintDeadline = object.complaintDeadline !== undefined && object.complaintDeadline !== null ? BigInt(object.complaintDeadline.toString()) : BigInt(0);
+        message.justificationDeadline = object.justificationDeadline !== undefined && object.justificationDeadline !== null ? BigInt(object.justificationDeadline.toString()) : BigInt(0);
+        message.disqualifiedDealers = object.disqualifiedDealers?.map(e => e) || [];
         return message;
     },
     fromAmino(object) {
@@ -1346,6 +1481,13 @@ export const DKGState = {
         if (object.contributions_received !== undefined && object.contributions_received !== null) {
             message.contributionsReceived = BigInt(object.contributions_received);
         }
+        if (object.complaint_deadline !== undefined && object.complaint_deadline !== null) {
+            message.complaintDeadline = BigInt(object.complaint_deadline);
+        }
+        if (object.justification_deadline !== undefined && object.justification_deadline !== null) {
+            message.justificationDeadline = BigInt(object.justification_deadline);
+        }
+        message.disqualifiedDealers = object.disqualified_dealers?.map(e => e) || [];
         return message;
     },
     toAmino(message) {
@@ -1364,6 +1506,14 @@ export const DKGState = {
             obj.expected_validators = message.expectedValidators;
         }
         obj.contributions_received = message.contributionsReceived !== BigInt(0) ? message.contributionsReceived?.toString() : undefined;
+        obj.complaint_deadline = message.complaintDeadline !== BigInt(0) ? message.complaintDeadline?.toString() : undefined;
+        obj.justification_deadline = message.justificationDeadline !== BigInt(0) ? message.justificationDeadline?.toString() : undefined;
+        if (message.disqualifiedDealers) {
+            obj.disqualified_dealers = message.disqualifiedDealers.map(e => e);
+        }
+        else {
+            obj.disqualified_dealers = message.disqualifiedDealers;
+        }
         return obj;
     },
     fromAminoMsg(object) {
@@ -1693,7 +1843,9 @@ function createBaseDKGVoteExtension() {
         contributionPop: new Uint8Array(),
         feldmanCommitmentsG2: [],
         decryptionEpoch: BigInt(0),
-        decryptionShare: new Uint8Array()
+        decryptionShare: new Uint8Array(),
+        complaints: [],
+        justifications: []
     };
 }
 /**
@@ -1736,6 +1888,14 @@ export const DKGVoteExtension = {
         if (message.decryptionShare.length !== 0) {
             writer.uint32(82).bytes(message.decryptionShare);
         }
+        writer.uint32(90).fork();
+        for (const v of message.complaints) {
+            writer.uint32(v);
+        }
+        writer.ldelim();
+        for (const v of message.justifications) {
+            DKGJustification.encode(v, writer.uint32(98).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
@@ -1775,6 +1935,20 @@ export const DKGVoteExtension = {
                 case 10:
                     message.decryptionShare = reader.bytes();
                     break;
+                case 11:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.complaints.push(reader.uint32());
+                        }
+                    }
+                    else {
+                        message.complaints.push(reader.uint32());
+                    }
+                    break;
+                case 12:
+                    message.justifications.push(DKGJustification.decode(reader, reader.uint32()));
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1794,6 +1968,8 @@ export const DKGVoteExtension = {
         message.feldmanCommitmentsG2 = object.feldmanCommitmentsG2?.map(e => e) || [];
         message.decryptionEpoch = object.decryptionEpoch !== undefined && object.decryptionEpoch !== null ? BigInt(object.decryptionEpoch.toString()) : BigInt(0);
         message.decryptionShare = object.decryptionShare ?? new Uint8Array();
+        message.complaints = object.complaints?.map(e => e) || [];
+        message.justifications = object.justifications?.map(e => DKGJustification.fromPartial(e)) || [];
         return message;
     },
     fromAmino(object) {
@@ -1822,6 +1998,8 @@ export const DKGVoteExtension = {
         if (object.decryption_share !== undefined && object.decryption_share !== null) {
             message.decryptionShare = bytesFromBase64(object.decryption_share);
         }
+        message.complaints = object.complaints?.map(e => e) || [];
+        message.justifications = object.justifications?.map(e => DKGJustification.fromAmino(e)) || [];
         return message;
     },
     toAmino(message) {
@@ -1851,6 +2029,18 @@ export const DKGVoteExtension = {
         }
         obj.decryption_epoch = message.decryptionEpoch !== BigInt(0) ? message.decryptionEpoch?.toString() : undefined;
         obj.decryption_share = message.decryptionShare ? base64FromBytes(message.decryptionShare) : undefined;
+        if (message.complaints) {
+            obj.complaints = message.complaints.map(e => e);
+        }
+        else {
+            obj.complaints = message.complaints;
+        }
+        if (message.justifications) {
+            obj.justifications = message.justifications.map(e => e ? DKGJustification.toAmino(e) : undefined);
+        }
+        else {
+            obj.justifications = message.justifications;
+        }
         return obj;
     },
     fromAminoMsg(object) {
@@ -1869,6 +2059,197 @@ export const DKGVoteExtension = {
         };
     }
 };
+function createBaseDKGJustification() {
+    return {
+        complainerIndex: 0,
+        evaluation: new Uint8Array()
+    };
+}
+/**
+ * DKGJustification is a dealer's public answer to a complaint: p_i(j) for the
+ * complaining validator j, which anyone checks against the dealer's Feldman
+ * commitments.
+ * @name DKGJustification
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DKGJustification
+ */
+export const DKGJustification = {
+    typeUrl: "/sparkdream.shield.v1.DKGJustification",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.complainerIndex !== 0) {
+            writer.uint32(8).uint32(message.complainerIndex);
+        }
+        if (message.evaluation.length !== 0) {
+            writer.uint32(18).bytes(message.evaluation);
+        }
+        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 = createBaseDKGJustification();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.complainerIndex = reader.uint32();
+                    break;
+                case 2:
+                    message.evaluation = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDKGJustification();
+        message.complainerIndex = object.complainerIndex ?? 0;
+        message.evaluation = object.evaluation ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDKGJustification();
+        if (object.complainer_index !== undefined && object.complainer_index !== null) {
+            message.complainerIndex = object.complainer_index;
+        }
+        if (object.evaluation !== undefined && object.evaluation !== null) {
+            message.evaluation = bytesFromBase64(object.evaluation);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.complainer_index = message.complainerIndex === 0 ? undefined : message.complainerIndex;
+        obj.evaluation = message.evaluation ? base64FromBytes(message.evaluation) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DKGJustification.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DKGJustification.decode(message.value);
+    },
+    toProto(message) {
+        return DKGJustification.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DKGJustification",
+            value: DKGJustification.encode(message).finish()
+        };
+    }
+};
+function createBaseDKGComplaint() {
+    return {
+        dealerAddress: "",
+        complainerAddress: "",
+        justified: false,
+        evaluation: new Uint8Array()
+    };
+}
+/**
+ * DKGComplaint records a complaint by complainer_address against
+ * dealer_address in the current round and, once the dealer answers with a
+ * valid evaluation, that evaluation (the complainer uses it in place of the
+ * ciphertext it could not open).
+ * @name DKGComplaint
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DKGComplaint
+ */
+export const DKGComplaint = {
+    typeUrl: "/sparkdream.shield.v1.DKGComplaint",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.dealerAddress !== "") {
+            writer.uint32(10).string(message.dealerAddress);
+        }
+        if (message.complainerAddress !== "") {
+            writer.uint32(18).string(message.complainerAddress);
+        }
+        if (message.justified === true) {
+            writer.uint32(24).bool(message.justified);
+        }
+        if (message.evaluation.length !== 0) {
+            writer.uint32(34).bytes(message.evaluation);
+        }
+        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 = createBaseDKGComplaint();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.dealerAddress = reader.string();
+                    break;
+                case 2:
+                    message.complainerAddress = reader.string();
+                    break;
+                case 3:
+                    message.justified = reader.bool();
+                    break;
+                case 4:
+                    message.evaluation = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDKGComplaint();
+        message.dealerAddress = object.dealerAddress ?? "";
+        message.complainerAddress = object.complainerAddress ?? "";
+        message.justified = object.justified ?? false;
+        message.evaluation = object.evaluation ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDKGComplaint();
+        if (object.dealer_address !== undefined && object.dealer_address !== null) {
+            message.dealerAddress = object.dealer_address;
+        }
+        if (object.complainer_address !== undefined && object.complainer_address !== null) {
+            message.complainerAddress = object.complainer_address;
+        }
+        if (object.justified !== undefined && object.justified !== null) {
+            message.justified = object.justified;
+        }
+        if (object.evaluation !== undefined && object.evaluation !== null) {
+            message.evaluation = bytesFromBase64(object.evaluation);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.dealer_address = message.dealerAddress === "" ? undefined : message.dealerAddress;
+        obj.complainer_address = message.complainerAddress === "" ? undefined : message.complainerAddress;
+        obj.justified = message.justified === false ? undefined : message.justified;
+        obj.evaluation = message.evaluation ? base64FromBytes(message.evaluation) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DKGComplaint.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DKGComplaint.decode(message.value);
+    },
+    toProto(message) {
+        return DKGComplaint.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DKGComplaint",
+            value: DKGComplaint.encode(message).finish()
+        };
+    }
+};
 function createBaseInjectedDKGData() {
     return {
         round: BigInt(0),
@@ -2425,3 +2806,86 @@ export const TLEMissCounterEntry = {
         };
     }
 };
+function createBaseDecryptionDemandEntry() {
+    return {
+        epoch: BigInt(0),
+        height: BigInt(0)
+    };
+}
+/**
+ * DecryptionDemandEntry records that the EndBlocker asked validators for
+ * decryption shares of a closed epoch (its batch became ready) at a height.
+ * TLE liveness for that epoch is judged one full epoch interval later.
+ * @name DecryptionDemandEntry
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DecryptionDemandEntry
+ */
+export const DecryptionDemandEntry = {
+    typeUrl: "/sparkdream.shield.v1.DecryptionDemandEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epoch !== BigInt(0)) {
+            writer.uint32(8).uint64(message.epoch);
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(16).int64(message.height);
+        }
+        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 = createBaseDecryptionDemandEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epoch = reader.uint64();
+                    break;
+                case 2:
+                    message.height = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecryptionDemandEntry();
+        message.epoch = object.epoch !== undefined && object.epoch !== null ? BigInt(object.epoch.toString()) : BigInt(0);
+        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDecryptionDemandEntry();
+        if (object.epoch !== undefined && object.epoch !== null) {
+            message.epoch = BigInt(object.epoch);
+        }
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch = message.epoch !== BigInt(0) ? message.epoch?.toString() : undefined;
+        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DecryptionDemandEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DecryptionDemandEntry.decode(message.value);
+    },
+    toProto(message) {
+        return DecryptionDemandEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DecryptionDemandEntry",
+            value: DecryptionDemandEntry.encode(message).finish()
+        };
+    }
+};