@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.8

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

@@ -0,0 +1,2385 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/**
+ * ProofDomain identifies which Merkle tree the ZK proof targets.
+ * All anonymous operations use the trust tree (leaves = MiMC(zk_pub_key, trust_level)).
+ * The unified ShieldCircuit hides the exact trust level — only proves >= minimum.
+ */
+export var ProofDomain;
+(function (ProofDomain) {
+    ProofDomain[ProofDomain["PROOF_DOMAIN_UNSPECIFIED"] = 0] = "PROOF_DOMAIN_UNSPECIFIED";
+    ProofDomain[ProofDomain["PROOF_DOMAIN_TRUST_TREE"] = 1] = "PROOF_DOMAIN_TRUST_TREE";
+    ProofDomain[ProofDomain["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ProofDomain || (ProofDomain = {}));
+export const ProofDomainAmino = ProofDomain;
+export function proofDomainFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "PROOF_DOMAIN_UNSPECIFIED":
+            return ProofDomain.PROOF_DOMAIN_UNSPECIFIED;
+        case 1:
+        case "PROOF_DOMAIN_TRUST_TREE":
+            return ProofDomain.PROOF_DOMAIN_TRUST_TREE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ProofDomain.UNRECOGNIZED;
+    }
+}
+export function proofDomainToJSON(object) {
+    switch (object) {
+        case ProofDomain.PROOF_DOMAIN_UNSPECIFIED:
+            return "PROOF_DOMAIN_UNSPECIFIED";
+        case ProofDomain.PROOF_DOMAIN_TRUST_TREE:
+            return "PROOF_DOMAIN_TRUST_TREE";
+        case ProofDomain.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** NullifierScopeType determines nullifier uniqueness granularity. */
+export var NullifierScopeType;
+(function (NullifierScopeType) {
+    /** NULLIFIER_SCOPE_EPOCH - Scope = current epoch (one op per epoch) */
+    NullifierScopeType[NullifierScopeType["NULLIFIER_SCOPE_EPOCH"] = 0] = "NULLIFIER_SCOPE_EPOCH";
+    /** NULLIFIER_SCOPE_MESSAGE_FIELD - Scope = extracted from inner message (e.g. post_id for replies) */
+    NullifierScopeType[NullifierScopeType["NULLIFIER_SCOPE_MESSAGE_FIELD"] = 1] = "NULLIFIER_SCOPE_MESSAGE_FIELD";
+    /** NULLIFIER_SCOPE_GLOBAL - No scoping (nullifier is globally unique) */
+    NullifierScopeType[NullifierScopeType["NULLIFIER_SCOPE_GLOBAL"] = 2] = "NULLIFIER_SCOPE_GLOBAL";
+    NullifierScopeType[NullifierScopeType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(NullifierScopeType || (NullifierScopeType = {}));
+export const NullifierScopeTypeAmino = NullifierScopeType;
+export function nullifierScopeTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "NULLIFIER_SCOPE_EPOCH":
+            return NullifierScopeType.NULLIFIER_SCOPE_EPOCH;
+        case 1:
+        case "NULLIFIER_SCOPE_MESSAGE_FIELD":
+            return NullifierScopeType.NULLIFIER_SCOPE_MESSAGE_FIELD;
+        case 2:
+        case "NULLIFIER_SCOPE_GLOBAL":
+            return NullifierScopeType.NULLIFIER_SCOPE_GLOBAL;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return NullifierScopeType.UNRECOGNIZED;
+    }
+}
+export function nullifierScopeTypeToJSON(object) {
+    switch (object) {
+        case NullifierScopeType.NULLIFIER_SCOPE_EPOCH:
+            return "NULLIFIER_SCOPE_EPOCH";
+        case NullifierScopeType.NULLIFIER_SCOPE_MESSAGE_FIELD:
+            return "NULLIFIER_SCOPE_MESSAGE_FIELD";
+        case NullifierScopeType.NULLIFIER_SCOPE_GLOBAL:
+            return "NULLIFIER_SCOPE_GLOBAL";
+        case NullifierScopeType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** ShieldBatchMode controls which execution modes an operation supports. */
+export var ShieldBatchMode;
+(function (ShieldBatchMode) {
+    /** SHIELD_BATCH_MODE_IMMEDIATE_ONLY - Only immediate execution allowed */
+    ShieldBatchMode[ShieldBatchMode["SHIELD_BATCH_MODE_IMMEDIATE_ONLY"] = 0] = "SHIELD_BATCH_MODE_IMMEDIATE_ONLY";
+    /** SHIELD_BATCH_MODE_ENCRYPTED_ONLY - Only encrypted batch execution allowed */
+    ShieldBatchMode[ShieldBatchMode["SHIELD_BATCH_MODE_ENCRYPTED_ONLY"] = 1] = "SHIELD_BATCH_MODE_ENCRYPTED_ONLY";
+    /** SHIELD_BATCH_MODE_EITHER - User chooses per-submission */
+    ShieldBatchMode[ShieldBatchMode["SHIELD_BATCH_MODE_EITHER"] = 2] = "SHIELD_BATCH_MODE_EITHER";
+    ShieldBatchMode[ShieldBatchMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ShieldBatchMode || (ShieldBatchMode = {}));
+export const ShieldBatchModeAmino = ShieldBatchMode;
+export function shieldBatchModeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SHIELD_BATCH_MODE_IMMEDIATE_ONLY":
+            return ShieldBatchMode.SHIELD_BATCH_MODE_IMMEDIATE_ONLY;
+        case 1:
+        case "SHIELD_BATCH_MODE_ENCRYPTED_ONLY":
+            return ShieldBatchMode.SHIELD_BATCH_MODE_ENCRYPTED_ONLY;
+        case 2:
+        case "SHIELD_BATCH_MODE_EITHER":
+            return ShieldBatchMode.SHIELD_BATCH_MODE_EITHER;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ShieldBatchMode.UNRECOGNIZED;
+    }
+}
+export function shieldBatchModeToJSON(object) {
+    switch (object) {
+        case ShieldBatchMode.SHIELD_BATCH_MODE_IMMEDIATE_ONLY:
+            return "SHIELD_BATCH_MODE_IMMEDIATE_ONLY";
+        case ShieldBatchMode.SHIELD_BATCH_MODE_ENCRYPTED_ONLY:
+            return "SHIELD_BATCH_MODE_ENCRYPTED_ONLY";
+        case ShieldBatchMode.SHIELD_BATCH_MODE_EITHER:
+            return "SHIELD_BATCH_MODE_EITHER";
+        case ShieldBatchMode.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** ShieldExecMode selects the execution mode for a shielded operation. */
+export var ShieldExecMode;
+(function (ShieldExecMode) {
+    ShieldExecMode[ShieldExecMode["SHIELD_EXEC_IMMEDIATE"] = 0] = "SHIELD_EXEC_IMMEDIATE";
+    ShieldExecMode[ShieldExecMode["SHIELD_EXEC_ENCRYPTED_BATCH"] = 1] = "SHIELD_EXEC_ENCRYPTED_BATCH";
+    ShieldExecMode[ShieldExecMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ShieldExecMode || (ShieldExecMode = {}));
+export const ShieldExecModeAmino = ShieldExecMode;
+export function shieldExecModeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SHIELD_EXEC_IMMEDIATE":
+            return ShieldExecMode.SHIELD_EXEC_IMMEDIATE;
+        case 1:
+        case "SHIELD_EXEC_ENCRYPTED_BATCH":
+            return ShieldExecMode.SHIELD_EXEC_ENCRYPTED_BATCH;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ShieldExecMode.UNRECOGNIZED;
+    }
+}
+export function shieldExecModeToJSON(object) {
+    switch (object) {
+        case ShieldExecMode.SHIELD_EXEC_IMMEDIATE:
+            return "SHIELD_EXEC_IMMEDIATE";
+        case ShieldExecMode.SHIELD_EXEC_ENCRYPTED_BATCH:
+            return "SHIELD_EXEC_ENCRYPTED_BATCH";
+        case ShieldExecMode.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** DKGPhase tracks the current phase of the distributed key generation ceremony. */
+export var DKGPhase;
+(function (DKGPhase) {
+    /** DKG_PHASE_INACTIVE - No DKG running (not enough validators, or TLE not needed yet) */
+    DKGPhase[DKGPhase["DKG_PHASE_INACTIVE"] = 0] = "DKG_PHASE_INACTIVE";
+    /** DKG_PHASE_REGISTERING - Accepting BN256 G1 encryption key registrations from validators */
+    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 */
+    DKGPhase[DKGPhase["DKG_PHASE_ACTIVE"] = 3] = "DKG_PHASE_ACTIVE";
+    DKGPhase[DKGPhase["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(DKGPhase || (DKGPhase = {}));
+export const DKGPhaseAmino = DKGPhase;
+export function dKGPhaseFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "DKG_PHASE_INACTIVE":
+            return DKGPhase.DKG_PHASE_INACTIVE;
+        case 1:
+        case "DKG_PHASE_REGISTERING":
+            return DKGPhase.DKG_PHASE_REGISTERING;
+        case 2:
+        case "DKG_PHASE_CONTRIBUTING":
+            return DKGPhase.DKG_PHASE_CONTRIBUTING;
+        case 3:
+        case "DKG_PHASE_ACTIVE":
+            return DKGPhase.DKG_PHASE_ACTIVE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return DKGPhase.UNRECOGNIZED;
+    }
+}
+export function dKGPhaseToJSON(object) {
+    switch (object) {
+        case DKGPhase.DKG_PHASE_INACTIVE:
+            return "DKG_PHASE_INACTIVE";
+        case DKGPhase.DKG_PHASE_REGISTERING:
+            return "DKG_PHASE_REGISTERING";
+        case DKGPhase.DKG_PHASE_CONTRIBUTING:
+            return "DKG_PHASE_CONTRIBUTING";
+        case DKGPhase.DKG_PHASE_ACTIVE:
+            return "DKG_PHASE_ACTIVE";
+        case DKGPhase.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseShieldedOpRegistration() {
+    return {
+        messageTypeUrl: "",
+        proofDomain: 0,
+        minTrustLevel: 0,
+        nullifierDomain: 0,
+        nullifierScopeType: 0,
+        active: false,
+        batchMode: 0,
+        scopeFieldPath: ""
+    };
+}
+/**
+ * ShieldedOpRegistration defines a registered shielded operation.
+ * @name ShieldedOpRegistration
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.ShieldedOpRegistration
+ */
+export const ShieldedOpRegistration = {
+    typeUrl: "/sparkdream.shield.v1.ShieldedOpRegistration",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.messageTypeUrl !== "") {
+            writer.uint32(10).string(message.messageTypeUrl);
+        }
+        if (message.proofDomain !== 0) {
+            writer.uint32(16).int32(message.proofDomain);
+        }
+        if (message.minTrustLevel !== 0) {
+            writer.uint32(24).uint32(message.minTrustLevel);
+        }
+        if (message.nullifierDomain !== 0) {
+            writer.uint32(32).uint32(message.nullifierDomain);
+        }
+        if (message.nullifierScopeType !== 0) {
+            writer.uint32(40).int32(message.nullifierScopeType);
+        }
+        if (message.active === true) {
+            writer.uint32(48).bool(message.active);
+        }
+        if (message.batchMode !== 0) {
+            writer.uint32(56).int32(message.batchMode);
+        }
+        if (message.scopeFieldPath !== "") {
+            writer.uint32(66).string(message.scopeFieldPath);
+        }
+        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 = createBaseShieldedOpRegistration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.messageTypeUrl = reader.string();
+                    break;
+                case 2:
+                    message.proofDomain = reader.int32();
+                    break;
+                case 3:
+                    message.minTrustLevel = reader.uint32();
+                    break;
+                case 4:
+                    message.nullifierDomain = reader.uint32();
+                    break;
+                case 5:
+                    message.nullifierScopeType = reader.int32();
+                    break;
+                case 6:
+                    message.active = reader.bool();
+                    break;
+                case 7:
+                    message.batchMode = reader.int32();
+                    break;
+                case 8:
+                    message.scopeFieldPath = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseShieldedOpRegistration();
+        message.messageTypeUrl = object.messageTypeUrl ?? "";
+        message.proofDomain = object.proofDomain ?? 0;
+        message.minTrustLevel = object.minTrustLevel ?? 0;
+        message.nullifierDomain = object.nullifierDomain ?? 0;
+        message.nullifierScopeType = object.nullifierScopeType ?? 0;
+        message.active = object.active ?? false;
+        message.batchMode = object.batchMode ?? 0;
+        message.scopeFieldPath = object.scopeFieldPath ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseShieldedOpRegistration();
+        if (object.message_type_url !== undefined && object.message_type_url !== null) {
+            message.messageTypeUrl = object.message_type_url;
+        }
+        if (object.proof_domain !== undefined && object.proof_domain !== null) {
+            message.proofDomain = object.proof_domain;
+        }
+        if (object.min_trust_level !== undefined && object.min_trust_level !== null) {
+            message.minTrustLevel = object.min_trust_level;
+        }
+        if (object.nullifier_domain !== undefined && object.nullifier_domain !== null) {
+            message.nullifierDomain = object.nullifier_domain;
+        }
+        if (object.nullifier_scope_type !== undefined && object.nullifier_scope_type !== null) {
+            message.nullifierScopeType = object.nullifier_scope_type;
+        }
+        if (object.active !== undefined && object.active !== null) {
+            message.active = object.active;
+        }
+        if (object.batch_mode !== undefined && object.batch_mode !== null) {
+            message.batchMode = object.batch_mode;
+        }
+        if (object.scope_field_path !== undefined && object.scope_field_path !== null) {
+            message.scopeFieldPath = object.scope_field_path;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.message_type_url = message.messageTypeUrl === "" ? undefined : message.messageTypeUrl;
+        obj.proof_domain = message.proofDomain === 0 ? undefined : message.proofDomain;
+        obj.min_trust_level = message.minTrustLevel === 0 ? undefined : message.minTrustLevel;
+        obj.nullifier_domain = message.nullifierDomain === 0 ? undefined : message.nullifierDomain;
+        obj.nullifier_scope_type = message.nullifierScopeType === 0 ? undefined : message.nullifierScopeType;
+        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;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ShieldedOpRegistration.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ShieldedOpRegistration.decode(message.value);
+    },
+    toProto(message) {
+        return ShieldedOpRegistration.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.ShieldedOpRegistration",
+            value: ShieldedOpRegistration.encode(message).finish()
+        };
+    }
+};
+function createBaseUsedNullifier() {
+    return {
+        domain: 0,
+        scope: BigInt(0),
+        nullifierHex: "",
+        usedAtHeight: BigInt(0)
+    };
+}
+/**
+ * UsedNullifier records a nullifier that has been consumed.
+ * Key: domain (uint32) + scope (uint64) + nullifier_hex (string)
+ * @name UsedNullifier
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.UsedNullifier
+ */
+export const UsedNullifier = {
+    typeUrl: "/sparkdream.shield.v1.UsedNullifier",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.domain !== 0) {
+            writer.uint32(8).uint32(message.domain);
+        }
+        if (message.scope !== BigInt(0)) {
+            writer.uint32(16).uint64(message.scope);
+        }
+        if (message.nullifierHex !== "") {
+            writer.uint32(26).string(message.nullifierHex);
+        }
+        if (message.usedAtHeight !== BigInt(0)) {
+            writer.uint32(32).int64(message.usedAtHeight);
+        }
+        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 = createBaseUsedNullifier();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.domain = reader.uint32();
+                    break;
+                case 2:
+                    message.scope = reader.uint64();
+                    break;
+                case 3:
+                    message.nullifierHex = reader.string();
+                    break;
+                case 4:
+                    message.usedAtHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseUsedNullifier();
+        message.domain = object.domain ?? 0;
+        message.scope = object.scope !== undefined && object.scope !== null ? BigInt(object.scope.toString()) : BigInt(0);
+        message.nullifierHex = object.nullifierHex ?? "";
+        message.usedAtHeight = object.usedAtHeight !== undefined && object.usedAtHeight !== null ? BigInt(object.usedAtHeight.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseUsedNullifier();
+        if (object.domain !== undefined && object.domain !== null) {
+            message.domain = object.domain;
+        }
+        if (object.scope !== undefined && object.scope !== null) {
+            message.scope = BigInt(object.scope);
+        }
+        if (object.nullifier_hex !== undefined && object.nullifier_hex !== null) {
+            message.nullifierHex = object.nullifier_hex;
+        }
+        if (object.used_at_height !== undefined && object.used_at_height !== null) {
+            message.usedAtHeight = BigInt(object.used_at_height);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.domain = message.domain === 0 ? undefined : message.domain;
+        obj.scope = message.scope !== BigInt(0) ? message.scope?.toString() : undefined;
+        obj.nullifier_hex = message.nullifierHex === "" ? undefined : message.nullifierHex;
+        obj.used_at_height = message.usedAtHeight !== BigInt(0) ? message.usedAtHeight?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return UsedNullifier.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return UsedNullifier.decode(message.value);
+    },
+    toProto(message) {
+        return UsedNullifier.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.UsedNullifier",
+            value: UsedNullifier.encode(message).finish()
+        };
+    }
+};
+function createBaseDayFunding() {
+    return {
+        day: BigInt(0),
+        amountFunded: ""
+    };
+}
+/**
+ * DayFunding tracks funding per day to enforce the daily cap.
+ * Day is calculated as block_height / 14400 (at 6s/block = 1 day).
+ * @name DayFunding
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DayFunding
+ */
+export const DayFunding = {
+    typeUrl: "/sparkdream.shield.v1.DayFunding",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.day !== BigInt(0)) {
+            writer.uint32(8).uint64(message.day);
+        }
+        if (message.amountFunded !== "") {
+            writer.uint32(18).string(message.amountFunded);
+        }
+        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 = createBaseDayFunding();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.day = reader.uint64();
+                    break;
+                case 2:
+                    message.amountFunded = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDayFunding();
+        message.day = object.day !== undefined && object.day !== null ? BigInt(object.day.toString()) : BigInt(0);
+        message.amountFunded = object.amountFunded ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDayFunding();
+        if (object.day !== undefined && object.day !== null) {
+            message.day = BigInt(object.day);
+        }
+        if (object.amount_funded !== undefined && object.amount_funded !== null) {
+            message.amountFunded = object.amount_funded;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.day = message.day !== BigInt(0) ? message.day?.toString() : undefined;
+        obj.amount_funded = message.amountFunded === "" ? undefined : message.amountFunded;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DayFunding.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DayFunding.decode(message.value);
+    },
+    toProto(message) {
+        return DayFunding.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DayFunding",
+            value: DayFunding.encode(message).finish()
+        };
+    }
+};
+function createBasePendingShieldedOp() {
+    return {
+        id: BigInt(0),
+        targetEpoch: BigInt(0),
+        nullifier: new Uint8Array(),
+        merkleRoot: new Uint8Array(),
+        proofDomain: 0,
+        minTrustLevel: 0,
+        encryptedPayload: new Uint8Array(),
+        submittedAtHeight: BigInt(0),
+        submittedAtEpoch: BigInt(0)
+    };
+}
+/**
+ * PendingShieldedOp is stored in queue until the shield epoch boundary triggers batch execution.
+ * @name PendingShieldedOp
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.PendingShieldedOp
+ */
+export const PendingShieldedOp = {
+    typeUrl: "/sparkdream.shield.v1.PendingShieldedOp",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        if (message.targetEpoch !== BigInt(0)) {
+            writer.uint32(16).uint64(message.targetEpoch);
+        }
+        if (message.nullifier.length !== 0) {
+            writer.uint32(26).bytes(message.nullifier);
+        }
+        if (message.merkleRoot.length !== 0) {
+            writer.uint32(34).bytes(message.merkleRoot);
+        }
+        if (message.proofDomain !== 0) {
+            writer.uint32(40).int32(message.proofDomain);
+        }
+        if (message.minTrustLevel !== 0) {
+            writer.uint32(48).uint32(message.minTrustLevel);
+        }
+        if (message.encryptedPayload.length !== 0) {
+            writer.uint32(58).bytes(message.encryptedPayload);
+        }
+        if (message.submittedAtHeight !== BigInt(0)) {
+            writer.uint32(64).int64(message.submittedAtHeight);
+        }
+        if (message.submittedAtEpoch !== BigInt(0)) {
+            writer.uint32(72).uint64(message.submittedAtEpoch);
+        }
+        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 = createBasePendingShieldedOp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                case 2:
+                    message.targetEpoch = reader.uint64();
+                    break;
+                case 3:
+                    message.nullifier = reader.bytes();
+                    break;
+                case 4:
+                    message.merkleRoot = reader.bytes();
+                    break;
+                case 5:
+                    message.proofDomain = reader.int32();
+                    break;
+                case 6:
+                    message.minTrustLevel = reader.uint32();
+                    break;
+                case 7:
+                    message.encryptedPayload = reader.bytes();
+                    break;
+                case 8:
+                    message.submittedAtHeight = reader.int64();
+                    break;
+                case 9:
+                    message.submittedAtEpoch = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        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.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);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePendingShieldedOp();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        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.merkle_root !== undefined && object.merkle_root !== null) {
+            message.merkleRoot = bytesFromBase64(object.merkle_root);
+        }
+        if (object.proof_domain !== undefined && object.proof_domain !== null) {
+            message.proofDomain = object.proof_domain;
+        }
+        if (object.min_trust_level !== undefined && object.min_trust_level !== null) {
+            message.minTrustLevel = object.min_trust_level;
+        }
+        if (object.encrypted_payload !== undefined && object.encrypted_payload !== null) {
+            message.encryptedPayload = bytesFromBase64(object.encrypted_payload);
+        }
+        if (object.submitted_at_height !== undefined && object.submitted_at_height !== null) {
+            message.submittedAtHeight = BigInt(object.submitted_at_height);
+        }
+        if (object.submitted_at_epoch !== undefined && object.submitted_at_epoch !== null) {
+            message.submittedAtEpoch = BigInt(object.submitted_at_epoch);
+        }
+        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.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;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PendingShieldedOp.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PendingShieldedOp.decode(message.value);
+    },
+    toProto(message) {
+        return PendingShieldedOp.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.PendingShieldedOp",
+            value: PendingShieldedOp.encode(message).finish()
+        };
+    }
+};
+function createBaseShieldEpochState() {
+    return {
+        currentEpoch: BigInt(0),
+        epochStartHeight: BigInt(0),
+        decryptionKeyAvailable: false
+    };
+}
+/**
+ * ShieldEpochState tracks the current shield epoch and decryption key availability.
+ * @name ShieldEpochState
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.ShieldEpochState
+ */
+export const ShieldEpochState = {
+    typeUrl: "/sparkdream.shield.v1.ShieldEpochState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.currentEpoch !== BigInt(0)) {
+            writer.uint32(8).uint64(message.currentEpoch);
+        }
+        if (message.epochStartHeight !== BigInt(0)) {
+            writer.uint32(16).int64(message.epochStartHeight);
+        }
+        if (message.decryptionKeyAvailable === true) {
+            writer.uint32(24).bool(message.decryptionKeyAvailable);
+        }
+        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 = createBaseShieldEpochState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.currentEpoch = reader.uint64();
+                    break;
+                case 2:
+                    message.epochStartHeight = reader.int64();
+                    break;
+                case 3:
+                    message.decryptionKeyAvailable = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseShieldEpochState();
+        message.currentEpoch = object.currentEpoch !== undefined && object.currentEpoch !== null ? BigInt(object.currentEpoch.toString()) : BigInt(0);
+        message.epochStartHeight = object.epochStartHeight !== undefined && object.epochStartHeight !== null ? BigInt(object.epochStartHeight.toString()) : BigInt(0);
+        message.decryptionKeyAvailable = object.decryptionKeyAvailable ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseShieldEpochState();
+        if (object.current_epoch !== undefined && object.current_epoch !== null) {
+            message.currentEpoch = BigInt(object.current_epoch);
+        }
+        if (object.epoch_start_height !== undefined && object.epoch_start_height !== null) {
+            message.epochStartHeight = BigInt(object.epoch_start_height);
+        }
+        if (object.decryption_key_available !== undefined && object.decryption_key_available !== null) {
+            message.decryptionKeyAvailable = object.decryption_key_available;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.current_epoch = message.currentEpoch !== BigInt(0) ? message.currentEpoch?.toString() : undefined;
+        obj.epoch_start_height = message.epochStartHeight !== BigInt(0) ? message.epochStartHeight?.toString() : undefined;
+        obj.decryption_key_available = message.decryptionKeyAvailable === false ? undefined : message.decryptionKeyAvailable;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ShieldEpochState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ShieldEpochState.decode(message.value);
+    },
+    toProto(message) {
+        return ShieldEpochState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.ShieldEpochState",
+            value: ShieldEpochState.encode(message).finish()
+        };
+    }
+};
+function createBaseShieldEpochDecryptionKey() {
+    return {
+        epoch: BigInt(0),
+        decryptionKey: new Uint8Array(),
+        reconstructedAtHeight: BigInt(0)
+    };
+}
+/**
+ * ShieldEpochDecryptionKey is the reconstructed epoch decryption key.
+ * @name ShieldEpochDecryptionKey
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.ShieldEpochDecryptionKey
+ */
+export const ShieldEpochDecryptionKey = {
+    typeUrl: "/sparkdream.shield.v1.ShieldEpochDecryptionKey",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epoch !== BigInt(0)) {
+            writer.uint32(8).uint64(message.epoch);
+        }
+        if (message.decryptionKey.length !== 0) {
+            writer.uint32(18).bytes(message.decryptionKey);
+        }
+        if (message.reconstructedAtHeight !== BigInt(0)) {
+            writer.uint32(24).int64(message.reconstructedAtHeight);
+        }
+        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 = createBaseShieldEpochDecryptionKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epoch = reader.uint64();
+                    break;
+                case 2:
+                    message.decryptionKey = reader.bytes();
+                    break;
+                case 3:
+                    message.reconstructedAtHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseShieldEpochDecryptionKey();
+        message.epoch = object.epoch !== undefined && object.epoch !== null ? BigInt(object.epoch.toString()) : BigInt(0);
+        message.decryptionKey = object.decryptionKey ?? new Uint8Array();
+        message.reconstructedAtHeight = object.reconstructedAtHeight !== undefined && object.reconstructedAtHeight !== null ? BigInt(object.reconstructedAtHeight.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseShieldEpochDecryptionKey();
+        if (object.epoch !== undefined && object.epoch !== null) {
+            message.epoch = BigInt(object.epoch);
+        }
+        if (object.decryption_key !== undefined && object.decryption_key !== null) {
+            message.decryptionKey = bytesFromBase64(object.decryption_key);
+        }
+        if (object.reconstructed_at_height !== undefined && object.reconstructed_at_height !== null) {
+            message.reconstructedAtHeight = BigInt(object.reconstructed_at_height);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch = message.epoch !== BigInt(0) ? message.epoch?.toString() : undefined;
+        obj.decryption_key = message.decryptionKey ? base64FromBytes(message.decryptionKey) : undefined;
+        obj.reconstructed_at_height = message.reconstructedAtHeight !== BigInt(0) ? message.reconstructedAtHeight?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ShieldEpochDecryptionKey.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ShieldEpochDecryptionKey.decode(message.value);
+    },
+    toProto(message) {
+        return ShieldEpochDecryptionKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.ShieldEpochDecryptionKey",
+            value: ShieldEpochDecryptionKey.encode(message).finish()
+        };
+    }
+};
+function createBaseShieldDecryptionShare() {
+    return {
+        epoch: BigInt(0),
+        validator: "",
+        share: new Uint8Array()
+    };
+}
+/**
+ * ShieldDecryptionShare is a validator's decryption share for a shield epoch.
+ * @name ShieldDecryptionShare
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.ShieldDecryptionShare
+ */
+export const ShieldDecryptionShare = {
+    typeUrl: "/sparkdream.shield.v1.ShieldDecryptionShare",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epoch !== BigInt(0)) {
+            writer.uint32(8).uint64(message.epoch);
+        }
+        if (message.validator !== "") {
+            writer.uint32(18).string(message.validator);
+        }
+        if (message.share.length !== 0) {
+            writer.uint32(26).bytes(message.share);
+        }
+        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 = createBaseShieldDecryptionShare();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epoch = reader.uint64();
+                    break;
+                case 2:
+                    message.validator = reader.string();
+                    break;
+                case 3:
+                    message.share = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseShieldDecryptionShare();
+        message.epoch = object.epoch !== undefined && object.epoch !== null ? BigInt(object.epoch.toString()) : BigInt(0);
+        message.validator = object.validator ?? "";
+        message.share = object.share ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseShieldDecryptionShare();
+        if (object.epoch !== undefined && object.epoch !== null) {
+            message.epoch = BigInt(object.epoch);
+        }
+        if (object.validator !== undefined && object.validator !== null) {
+            message.validator = object.validator;
+        }
+        if (object.share !== undefined && object.share !== null) {
+            message.share = bytesFromBase64(object.share);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch = message.epoch !== BigInt(0) ? message.epoch?.toString() : undefined;
+        obj.validator = message.validator === "" ? undefined : message.validator;
+        obj.share = message.share ? base64FromBytes(message.share) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ShieldDecryptionShare.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ShieldDecryptionShare.decode(message.value);
+    },
+    toProto(message) {
+        return ShieldDecryptionShare.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.ShieldDecryptionShare",
+            value: ShieldDecryptionShare.encode(message).finish()
+        };
+    }
+};
+function createBaseTLEKeySet() {
+    return {
+        masterPublicKey: new Uint8Array(),
+        thresholdNumerator: BigInt(0),
+        thresholdDenominator: BigInt(0),
+        validatorShares: [],
+        createdAtHeight: BigInt(0)
+    };
+}
+/**
+ * TLEKeySet stores the master public key and validator shares from the DKG ceremony.
+ * @name TLEKeySet
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.TLEKeySet
+ */
+export const TLEKeySet = {
+    typeUrl: "/sparkdream.shield.v1.TLEKeySet",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.masterPublicKey.length !== 0) {
+            writer.uint32(10).bytes(message.masterPublicKey);
+        }
+        if (message.thresholdNumerator !== BigInt(0)) {
+            writer.uint32(16).uint64(message.thresholdNumerator);
+        }
+        if (message.thresholdDenominator !== BigInt(0)) {
+            writer.uint32(24).uint64(message.thresholdDenominator);
+        }
+        for (const v of message.validatorShares) {
+            TLEValidatorPublicShare.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.createdAtHeight !== BigInt(0)) {
+            writer.uint32(40).int64(message.createdAtHeight);
+        }
+        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 = createBaseTLEKeySet();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.masterPublicKey = reader.bytes();
+                    break;
+                case 2:
+                    message.thresholdNumerator = reader.uint64();
+                    break;
+                case 3:
+                    message.thresholdDenominator = reader.uint64();
+                    break;
+                case 4:
+                    message.validatorShares.push(TLEValidatorPublicShare.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.createdAtHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTLEKeySet();
+        message.masterPublicKey = object.masterPublicKey ?? new Uint8Array();
+        message.thresholdNumerator = object.thresholdNumerator !== undefined && object.thresholdNumerator !== null ? BigInt(object.thresholdNumerator.toString()) : BigInt(0);
+        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);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTLEKeySet();
+        if (object.master_public_key !== undefined && object.master_public_key !== null) {
+            message.masterPublicKey = bytesFromBase64(object.master_public_key);
+        }
+        if (object.threshold_numerator !== undefined && object.threshold_numerator !== null) {
+            message.thresholdNumerator = BigInt(object.threshold_numerator);
+        }
+        if (object.threshold_denominator !== undefined && object.threshold_denominator !== null) {
+            message.thresholdDenominator = BigInt(object.threshold_denominator);
+        }
+        message.validatorShares = object.validator_shares?.map(e => TLEValidatorPublicShare.fromAmino(e)) || [];
+        if (object.created_at_height !== undefined && object.created_at_height !== null) {
+            message.createdAtHeight = BigInt(object.created_at_height);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.master_public_key = message.masterPublicKey ? base64FromBytes(message.masterPublicKey) : undefined;
+        obj.threshold_numerator = message.thresholdNumerator !== BigInt(0) ? message.thresholdNumerator?.toString() : undefined;
+        obj.threshold_denominator = message.thresholdDenominator !== BigInt(0) ? message.thresholdDenominator?.toString() : undefined;
+        if (message.validatorShares) {
+            obj.validator_shares = message.validatorShares.map(e => e ? TLEValidatorPublicShare.toAmino(e) : undefined);
+        }
+        else {
+            obj.validator_shares = message.validatorShares;
+        }
+        obj.created_at_height = message.createdAtHeight !== BigInt(0) ? message.createdAtHeight?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return TLEKeySet.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return TLEKeySet.decode(message.value);
+    },
+    toProto(message) {
+        return TLEKeySet.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.TLEKeySet",
+            value: TLEKeySet.encode(message).finish()
+        };
+    }
+};
+function createBaseTLEValidatorPublicShare() {
+    return {
+        validatorAddress: "",
+        publicShare: new Uint8Array(),
+        shareIndex: 0
+    };
+}
+/**
+ * TLEValidatorPublicShare stores a validator's public key share from the DKG.
+ * @name TLEValidatorPublicShare
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.TLEValidatorPublicShare
+ */
+export const TLEValidatorPublicShare = {
+    typeUrl: "/sparkdream.shield.v1.TLEValidatorPublicShare",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validatorAddress !== "") {
+            writer.uint32(10).string(message.validatorAddress);
+        }
+        if (message.publicShare.length !== 0) {
+            writer.uint32(18).bytes(message.publicShare);
+        }
+        if (message.shareIndex !== 0) {
+            writer.uint32(24).uint32(message.shareIndex);
+        }
+        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 = createBaseTLEValidatorPublicShare();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorAddress = reader.string();
+                    break;
+                case 2:
+                    message.publicShare = reader.bytes();
+                    break;
+                case 3:
+                    message.shareIndex = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTLEValidatorPublicShare();
+        message.validatorAddress = object.validatorAddress ?? "";
+        message.publicShare = object.publicShare ?? new Uint8Array();
+        message.shareIndex = object.shareIndex ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTLEValidatorPublicShare();
+        if (object.validator_address !== undefined && object.validator_address !== null) {
+            message.validatorAddress = object.validator_address;
+        }
+        if (object.public_share !== undefined && object.public_share !== null) {
+            message.publicShare = bytesFromBase64(object.public_share);
+        }
+        if (object.share_index !== undefined && object.share_index !== null) {
+            message.shareIndex = object.share_index;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+        obj.public_share = message.publicShare ? base64FromBytes(message.publicShare) : undefined;
+        obj.share_index = message.shareIndex === 0 ? undefined : message.shareIndex;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return TLEValidatorPublicShare.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return TLEValidatorPublicShare.decode(message.value);
+    },
+    toProto(message) {
+        return TLEValidatorPublicShare.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.TLEValidatorPublicShare",
+            value: TLEValidatorPublicShare.encode(message).finish()
+        };
+    }
+};
+function createBaseDKGState() {
+    return {
+        round: BigInt(0),
+        phase: 0,
+        openAtHeight: BigInt(0),
+        registrationDeadline: BigInt(0),
+        contributionDeadline: BigInt(0),
+        thresholdNumerator: BigInt(0),
+        thresholdDenominator: BigInt(0),
+        expectedValidators: [],
+        contributionsReceived: BigInt(0)
+    };
+}
+/**
+ * DKGState tracks the current state of the on-chain Feldman DKG ceremony.
+ * @name DKGState
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DKGState
+ */
+export const DKGState = {
+    typeUrl: "/sparkdream.shield.v1.DKGState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.round !== BigInt(0)) {
+            writer.uint32(8).uint64(message.round);
+        }
+        if (message.phase !== 0) {
+            writer.uint32(16).int32(message.phase);
+        }
+        if (message.openAtHeight !== BigInt(0)) {
+            writer.uint32(24).int64(message.openAtHeight);
+        }
+        if (message.registrationDeadline !== BigInt(0)) {
+            writer.uint32(32).int64(message.registrationDeadline);
+        }
+        if (message.contributionDeadline !== BigInt(0)) {
+            writer.uint32(40).int64(message.contributionDeadline);
+        }
+        if (message.thresholdNumerator !== BigInt(0)) {
+            writer.uint32(48).uint64(message.thresholdNumerator);
+        }
+        if (message.thresholdDenominator !== BigInt(0)) {
+            writer.uint32(56).uint64(message.thresholdDenominator);
+        }
+        for (const v of message.expectedValidators) {
+            writer.uint32(66).string(v);
+        }
+        if (message.contributionsReceived !== BigInt(0)) {
+            writer.uint32(72).uint64(message.contributionsReceived);
+        }
+        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 = createBaseDKGState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.round = reader.uint64();
+                    break;
+                case 2:
+                    message.phase = reader.int32();
+                    break;
+                case 3:
+                    message.openAtHeight = reader.int64();
+                    break;
+                case 4:
+                    message.registrationDeadline = reader.int64();
+                    break;
+                case 5:
+                    message.contributionDeadline = reader.int64();
+                    break;
+                case 6:
+                    message.thresholdNumerator = reader.uint64();
+                    break;
+                case 7:
+                    message.thresholdDenominator = reader.uint64();
+                    break;
+                case 8:
+                    message.expectedValidators.push(reader.string());
+                    break;
+                case 9:
+                    message.contributionsReceived = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDKGState();
+        message.round = object.round !== undefined && object.round !== null ? BigInt(object.round.toString()) : BigInt(0);
+        message.phase = object.phase ?? 0;
+        message.openAtHeight = object.openAtHeight !== undefined && object.openAtHeight !== null ? BigInt(object.openAtHeight.toString()) : BigInt(0);
+        message.registrationDeadline = object.registrationDeadline !== undefined && object.registrationDeadline !== null ? BigInt(object.registrationDeadline.toString()) : BigInt(0);
+        message.contributionDeadline = object.contributionDeadline !== undefined && object.contributionDeadline !== null ? BigInt(object.contributionDeadline.toString()) : BigInt(0);
+        message.thresholdNumerator = object.thresholdNumerator !== undefined && object.thresholdNumerator !== null ? BigInt(object.thresholdNumerator.toString()) : BigInt(0);
+        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);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDKGState();
+        if (object.round !== undefined && object.round !== null) {
+            message.round = BigInt(object.round);
+        }
+        if (object.phase !== undefined && object.phase !== null) {
+            message.phase = object.phase;
+        }
+        if (object.open_at_height !== undefined && object.open_at_height !== null) {
+            message.openAtHeight = BigInt(object.open_at_height);
+        }
+        if (object.registration_deadline !== undefined && object.registration_deadline !== null) {
+            message.registrationDeadline = BigInt(object.registration_deadline);
+        }
+        if (object.contribution_deadline !== undefined && object.contribution_deadline !== null) {
+            message.contributionDeadline = BigInt(object.contribution_deadline);
+        }
+        if (object.threshold_numerator !== undefined && object.threshold_numerator !== null) {
+            message.thresholdNumerator = BigInt(object.threshold_numerator);
+        }
+        if (object.threshold_denominator !== undefined && object.threshold_denominator !== null) {
+            message.thresholdDenominator = BigInt(object.threshold_denominator);
+        }
+        message.expectedValidators = object.expected_validators?.map(e => e) || [];
+        if (object.contributions_received !== undefined && object.contributions_received !== null) {
+            message.contributionsReceived = BigInt(object.contributions_received);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.round = message.round !== BigInt(0) ? message.round?.toString() : undefined;
+        obj.phase = message.phase === 0 ? undefined : message.phase;
+        obj.open_at_height = message.openAtHeight !== BigInt(0) ? message.openAtHeight?.toString() : undefined;
+        obj.registration_deadline = message.registrationDeadline !== BigInt(0) ? message.registrationDeadline?.toString() : undefined;
+        obj.contribution_deadline = message.contributionDeadline !== BigInt(0) ? message.contributionDeadline?.toString() : undefined;
+        obj.threshold_numerator = message.thresholdNumerator !== BigInt(0) ? message.thresholdNumerator?.toString() : undefined;
+        obj.threshold_denominator = message.thresholdDenominator !== BigInt(0) ? message.thresholdDenominator?.toString() : undefined;
+        if (message.expectedValidators) {
+            obj.expected_validators = message.expectedValidators.map(e => e);
+        }
+        else {
+            obj.expected_validators = message.expectedValidators;
+        }
+        obj.contributions_received = message.contributionsReceived !== BigInt(0) ? message.contributionsReceived?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DKGState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DKGState.decode(message.value);
+    },
+    toProto(message) {
+        return DKGState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DKGState",
+            value: DKGState.encode(message).finish()
+        };
+    }
+};
+function createBaseDKGContribution() {
+    return {
+        validatorAddress: "",
+        round: BigInt(0),
+        feldmanCommitments: [],
+        encryptedEvaluations: [],
+        proofOfPossession: new Uint8Array()
+    };
+}
+/**
+ * DKGContribution is a validator's Feldman DKG contribution.
+ * @name DKGContribution
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DKGContribution
+ */
+export const DKGContribution = {
+    typeUrl: "/sparkdream.shield.v1.DKGContribution",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validatorAddress !== "") {
+            writer.uint32(10).string(message.validatorAddress);
+        }
+        if (message.round !== BigInt(0)) {
+            writer.uint32(16).uint64(message.round);
+        }
+        for (const v of message.feldmanCommitments) {
+            writer.uint32(26).bytes(v);
+        }
+        for (const v of message.encryptedEvaluations) {
+            EncryptedEvaluation.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.proofOfPossession.length !== 0) {
+            writer.uint32(42).bytes(message.proofOfPossession);
+        }
+        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 = createBaseDKGContribution();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorAddress = reader.string();
+                    break;
+                case 2:
+                    message.round = reader.uint64();
+                    break;
+                case 3:
+                    message.feldmanCommitments.push(reader.bytes());
+                    break;
+                case 4:
+                    message.encryptedEvaluations.push(EncryptedEvaluation.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.proofOfPossession = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDKGContribution();
+        message.validatorAddress = object.validatorAddress ?? "";
+        message.round = object.round !== undefined && object.round !== null ? BigInt(object.round.toString()) : BigInt(0);
+        message.feldmanCommitments = object.feldmanCommitments?.map(e => e) || [];
+        message.encryptedEvaluations = object.encryptedEvaluations?.map(e => EncryptedEvaluation.fromPartial(e)) || [];
+        message.proofOfPossession = object.proofOfPossession ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDKGContribution();
+        if (object.validator_address !== undefined && object.validator_address !== null) {
+            message.validatorAddress = object.validator_address;
+        }
+        if (object.round !== undefined && object.round !== null) {
+            message.round = BigInt(object.round);
+        }
+        message.feldmanCommitments = object.feldman_commitments?.map(e => bytesFromBase64(e)) || [];
+        message.encryptedEvaluations = object.encrypted_evaluations?.map(e => EncryptedEvaluation.fromAmino(e)) || [];
+        if (object.proof_of_possession !== undefined && object.proof_of_possession !== null) {
+            message.proofOfPossession = bytesFromBase64(object.proof_of_possession);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+        obj.round = message.round !== BigInt(0) ? message.round?.toString() : undefined;
+        if (message.feldmanCommitments) {
+            obj.feldman_commitments = message.feldmanCommitments.map(e => base64FromBytes(e));
+        }
+        else {
+            obj.feldman_commitments = message.feldmanCommitments;
+        }
+        if (message.encryptedEvaluations) {
+            obj.encrypted_evaluations = message.encryptedEvaluations.map(e => e ? EncryptedEvaluation.toAmino(e) : undefined);
+        }
+        else {
+            obj.encrypted_evaluations = message.encryptedEvaluations;
+        }
+        obj.proof_of_possession = message.proofOfPossession ? base64FromBytes(message.proofOfPossession) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DKGContribution.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DKGContribution.decode(message.value);
+    },
+    toProto(message) {
+        return DKGContribution.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DKGContribution",
+            value: DKGContribution.encode(message).finish()
+        };
+    }
+};
+function createBaseEncryptedEvaluation() {
+    return {
+        targetIndex: 0,
+        ciphertext: new Uint8Array()
+    };
+}
+/**
+ * EncryptedEvaluation is an ECIES-encrypted polynomial evaluation for a target validator.
+ * @name EncryptedEvaluation
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.EncryptedEvaluation
+ */
+export const EncryptedEvaluation = {
+    typeUrl: "/sparkdream.shield.v1.EncryptedEvaluation",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.targetIndex !== 0) {
+            writer.uint32(8).uint32(message.targetIndex);
+        }
+        if (message.ciphertext.length !== 0) {
+            writer.uint32(18).bytes(message.ciphertext);
+        }
+        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 = createBaseEncryptedEvaluation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.targetIndex = reader.uint32();
+                    break;
+                case 2:
+                    message.ciphertext = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEncryptedEvaluation();
+        message.targetIndex = object.targetIndex ?? 0;
+        message.ciphertext = object.ciphertext ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEncryptedEvaluation();
+        if (object.target_index !== undefined && object.target_index !== null) {
+            message.targetIndex = object.target_index;
+        }
+        if (object.ciphertext !== undefined && object.ciphertext !== null) {
+            message.ciphertext = bytesFromBase64(object.ciphertext);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.target_index = message.targetIndex === 0 ? undefined : message.targetIndex;
+        obj.ciphertext = message.ciphertext ? base64FromBytes(message.ciphertext) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return EncryptedEvaluation.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return EncryptedEvaluation.decode(message.value);
+    },
+    toProto(message) {
+        return EncryptedEvaluation.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.EncryptedEvaluation",
+            value: EncryptedEvaluation.encode(message).finish()
+        };
+    }
+};
+function createBaseDKGContributionEntry() {
+    return {
+        validatorAddress: "",
+        contribution: DKGContribution.fromPartial({})
+    };
+}
+/**
+ * DKGContributionEntry is a genesis helper for exporting DKG contributions.
+ * @name DKGContributionEntry
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DKGContributionEntry
+ */
+export const DKGContributionEntry = {
+    typeUrl: "/sparkdream.shield.v1.DKGContributionEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validatorAddress !== "") {
+            writer.uint32(10).string(message.validatorAddress);
+        }
+        if (message.contribution !== undefined) {
+            DKGContribution.encode(message.contribution, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDKGContributionEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorAddress = reader.string();
+                    break;
+                case 2:
+                    message.contribution = DKGContribution.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDKGContributionEntry();
+        message.validatorAddress = object.validatorAddress ?? "";
+        message.contribution = object.contribution !== undefined && object.contribution !== null ? DKGContribution.fromPartial(object.contribution) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDKGContributionEntry();
+        if (object.validator_address !== undefined && object.validator_address !== null) {
+            message.validatorAddress = object.validator_address;
+        }
+        if (object.contribution !== undefined && object.contribution !== null) {
+            message.contribution = DKGContribution.fromAmino(object.contribution);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+        obj.contribution = message.contribution ? DKGContribution.toAmino(message.contribution) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DKGContributionEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DKGContributionEntry.decode(message.value);
+    },
+    toProto(message) {
+        return DKGContributionEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DKGContributionEntry",
+            value: DKGContributionEntry.encode(message).finish()
+        };
+    }
+};
+function createBaseDKGVoteExtension() {
+    return {
+        round: BigInt(0),
+        phase: 0,
+        registrationPubKey: new Uint8Array(),
+        registrationPop: new Uint8Array(),
+        feldmanCommitments: [],
+        encryptedEvaluations: [],
+        contributionPop: new Uint8Array(),
+        decryptionEpoch: BigInt(0),
+        decryptionShare: new Uint8Array()
+    };
+}
+/**
+ * DKGVoteExtension is the payload validators embed in their vote extensions
+ * during DKG ceremonies. The type field determines which data is present.
+ * @name DKGVoteExtension
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.DKGVoteExtension
+ */
+export const DKGVoteExtension = {
+    typeUrl: "/sparkdream.shield.v1.DKGVoteExtension",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.round !== BigInt(0)) {
+            writer.uint32(8).uint64(message.round);
+        }
+        if (message.phase !== 0) {
+            writer.uint32(16).int32(message.phase);
+        }
+        if (message.registrationPubKey.length !== 0) {
+            writer.uint32(26).bytes(message.registrationPubKey);
+        }
+        if (message.registrationPop.length !== 0) {
+            writer.uint32(34).bytes(message.registrationPop);
+        }
+        for (const v of message.feldmanCommitments) {
+            writer.uint32(42).bytes(v);
+        }
+        for (const v of message.encryptedEvaluations) {
+            EncryptedEvaluation.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.contributionPop.length !== 0) {
+            writer.uint32(58).bytes(message.contributionPop);
+        }
+        if (message.decryptionEpoch !== BigInt(0)) {
+            writer.uint32(64).uint64(message.decryptionEpoch);
+        }
+        if (message.decryptionShare.length !== 0) {
+            writer.uint32(74).bytes(message.decryptionShare);
+        }
+        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 = createBaseDKGVoteExtension();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.round = reader.uint64();
+                    break;
+                case 2:
+                    message.phase = reader.int32();
+                    break;
+                case 3:
+                    message.registrationPubKey = reader.bytes();
+                    break;
+                case 4:
+                    message.registrationPop = reader.bytes();
+                    break;
+                case 5:
+                    message.feldmanCommitments.push(reader.bytes());
+                    break;
+                case 6:
+                    message.encryptedEvaluations.push(EncryptedEvaluation.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.contributionPop = reader.bytes();
+                    break;
+                case 8:
+                    message.decryptionEpoch = reader.uint64();
+                    break;
+                case 9:
+                    message.decryptionShare = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDKGVoteExtension();
+        message.round = object.round !== undefined && object.round !== null ? BigInt(object.round.toString()) : BigInt(0);
+        message.phase = object.phase ?? 0;
+        message.registrationPubKey = object.registrationPubKey ?? new Uint8Array();
+        message.registrationPop = object.registrationPop ?? new Uint8Array();
+        message.feldmanCommitments = object.feldmanCommitments?.map(e => e) || [];
+        message.encryptedEvaluations = object.encryptedEvaluations?.map(e => EncryptedEvaluation.fromPartial(e)) || [];
+        message.contributionPop = object.contributionPop ?? new Uint8Array();
+        message.decryptionEpoch = object.decryptionEpoch !== undefined && object.decryptionEpoch !== null ? BigInt(object.decryptionEpoch.toString()) : BigInt(0);
+        message.decryptionShare = object.decryptionShare ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDKGVoteExtension();
+        if (object.round !== undefined && object.round !== null) {
+            message.round = BigInt(object.round);
+        }
+        if (object.phase !== undefined && object.phase !== null) {
+            message.phase = object.phase;
+        }
+        if (object.registration_pub_key !== undefined && object.registration_pub_key !== null) {
+            message.registrationPubKey = bytesFromBase64(object.registration_pub_key);
+        }
+        if (object.registration_pop !== undefined && object.registration_pop !== null) {
+            message.registrationPop = bytesFromBase64(object.registration_pop);
+        }
+        message.feldmanCommitments = object.feldman_commitments?.map(e => bytesFromBase64(e)) || [];
+        message.encryptedEvaluations = object.encrypted_evaluations?.map(e => EncryptedEvaluation.fromAmino(e)) || [];
+        if (object.contribution_pop !== undefined && object.contribution_pop !== null) {
+            message.contributionPop = bytesFromBase64(object.contribution_pop);
+        }
+        if (object.decryption_epoch !== undefined && object.decryption_epoch !== null) {
+            message.decryptionEpoch = BigInt(object.decryption_epoch);
+        }
+        if (object.decryption_share !== undefined && object.decryption_share !== null) {
+            message.decryptionShare = bytesFromBase64(object.decryption_share);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.round = message.round !== BigInt(0) ? message.round?.toString() : undefined;
+        obj.phase = message.phase === 0 ? undefined : message.phase;
+        obj.registration_pub_key = message.registrationPubKey ? base64FromBytes(message.registrationPubKey) : undefined;
+        obj.registration_pop = message.registrationPop ? base64FromBytes(message.registrationPop) : undefined;
+        if (message.feldmanCommitments) {
+            obj.feldman_commitments = message.feldmanCommitments.map(e => base64FromBytes(e));
+        }
+        else {
+            obj.feldman_commitments = message.feldmanCommitments;
+        }
+        if (message.encryptedEvaluations) {
+            obj.encrypted_evaluations = message.encryptedEvaluations.map(e => e ? EncryptedEvaluation.toAmino(e) : undefined);
+        }
+        else {
+            obj.encrypted_evaluations = message.encryptedEvaluations;
+        }
+        obj.contribution_pop = message.contributionPop ? base64FromBytes(message.contributionPop) : undefined;
+        obj.decryption_epoch = message.decryptionEpoch !== BigInt(0) ? message.decryptionEpoch?.toString() : undefined;
+        obj.decryption_share = message.decryptionShare ? base64FromBytes(message.decryptionShare) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DKGVoteExtension.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DKGVoteExtension.decode(message.value);
+    },
+    toProto(message) {
+        return DKGVoteExtension.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.DKGVoteExtension",
+            value: DKGVoteExtension.encode(message).finish()
+        };
+    }
+};
+function createBaseInjectedDKGData() {
+    return {
+        round: BigInt(0),
+        phase: 0,
+        extensions: [],
+        decryptionShares: []
+    };
+}
+/**
+ * InjectedDKGData is the aggregated shield data injected by the block proposer
+ * as a pseudo-transaction at position 0 of the block.
+ * Carries DKG ceremony data (during REGISTERING/CONTRIBUTING) and/or
+ * epoch decryption shares (during ACTIVE phase with pending ops).
+ * @name InjectedDKGData
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.InjectedDKGData
+ */
+export const InjectedDKGData = {
+    typeUrl: "/sparkdream.shield.v1.InjectedDKGData",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.round !== BigInt(0)) {
+            writer.uint32(8).uint64(message.round);
+        }
+        if (message.phase !== 0) {
+            writer.uint32(16).int32(message.phase);
+        }
+        for (const v of message.extensions) {
+            ValidatorDKGExtension.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.decryptionShares) {
+            InjectedDecryptionShare.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInjectedDKGData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.round = reader.uint64();
+                    break;
+                case 2:
+                    message.phase = reader.int32();
+                    break;
+                case 3:
+                    message.extensions.push(ValidatorDKGExtension.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.decryptionShares.push(InjectedDecryptionShare.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseInjectedDKGData();
+        message.round = object.round !== undefined && object.round !== null ? BigInt(object.round.toString()) : BigInt(0);
+        message.phase = object.phase ?? 0;
+        message.extensions = object.extensions?.map(e => ValidatorDKGExtension.fromPartial(e)) || [];
+        message.decryptionShares = object.decryptionShares?.map(e => InjectedDecryptionShare.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseInjectedDKGData();
+        if (object.round !== undefined && object.round !== null) {
+            message.round = BigInt(object.round);
+        }
+        if (object.phase !== undefined && object.phase !== null) {
+            message.phase = object.phase;
+        }
+        message.extensions = object.extensions?.map(e => ValidatorDKGExtension.fromAmino(e)) || [];
+        message.decryptionShares = object.decryption_shares?.map(e => InjectedDecryptionShare.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.round = message.round !== BigInt(0) ? message.round?.toString() : undefined;
+        obj.phase = message.phase === 0 ? undefined : message.phase;
+        if (message.extensions) {
+            obj.extensions = message.extensions.map(e => e ? ValidatorDKGExtension.toAmino(e) : undefined);
+        }
+        else {
+            obj.extensions = message.extensions;
+        }
+        if (message.decryptionShares) {
+            obj.decryption_shares = message.decryptionShares.map(e => e ? InjectedDecryptionShare.toAmino(e) : undefined);
+        }
+        else {
+            obj.decryption_shares = message.decryptionShares;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return InjectedDKGData.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return InjectedDKGData.decode(message.value);
+    },
+    toProto(message) {
+        return InjectedDKGData.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.InjectedDKGData",
+            value: InjectedDKGData.encode(message).finish()
+        };
+    }
+};
+function createBaseInjectedDecryptionShare() {
+    return {
+        validatorAddress: new Uint8Array(),
+        epoch: BigInt(0),
+        share: new Uint8Array()
+    };
+}
+/**
+ * InjectedDecryptionShare pairs a validator's consensus address with their
+ * epoch decryption share for threshold reconstruction.
+ * @name InjectedDecryptionShare
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.InjectedDecryptionShare
+ */
+export const InjectedDecryptionShare = {
+    typeUrl: "/sparkdream.shield.v1.InjectedDecryptionShare",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validatorAddress.length !== 0) {
+            writer.uint32(10).bytes(message.validatorAddress);
+        }
+        if (message.epoch !== BigInt(0)) {
+            writer.uint32(16).uint64(message.epoch);
+        }
+        if (message.share.length !== 0) {
+            writer.uint32(26).bytes(message.share);
+        }
+        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 = createBaseInjectedDecryptionShare();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorAddress = reader.bytes();
+                    break;
+                case 2:
+                    message.epoch = reader.uint64();
+                    break;
+                case 3:
+                    message.share = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseInjectedDecryptionShare();
+        message.validatorAddress = object.validatorAddress ?? new Uint8Array();
+        message.epoch = object.epoch !== undefined && object.epoch !== null ? BigInt(object.epoch.toString()) : BigInt(0);
+        message.share = object.share ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseInjectedDecryptionShare();
+        if (object.validator_address !== undefined && object.validator_address !== null) {
+            message.validatorAddress = bytesFromBase64(object.validator_address);
+        }
+        if (object.epoch !== undefined && object.epoch !== null) {
+            message.epoch = BigInt(object.epoch);
+        }
+        if (object.share !== undefined && object.share !== null) {
+            message.share = bytesFromBase64(object.share);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.validator_address = message.validatorAddress ? base64FromBytes(message.validatorAddress) : undefined;
+        obj.epoch = message.epoch !== BigInt(0) ? message.epoch?.toString() : undefined;
+        obj.share = message.share ? base64FromBytes(message.share) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return InjectedDecryptionShare.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return InjectedDecryptionShare.decode(message.value);
+    },
+    toProto(message) {
+        return InjectedDecryptionShare.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.InjectedDecryptionShare",
+            value: InjectedDecryptionShare.encode(message).finish()
+        };
+    }
+};
+function createBaseValidatorDKGExtension() {
+    return {
+        validatorAddress: new Uint8Array(),
+        extension: DKGVoteExtension.fromPartial({})
+    };
+}
+/**
+ * ValidatorDKGExtension pairs a validator's consensus address with their DKG vote extension.
+ * @name ValidatorDKGExtension
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.ValidatorDKGExtension
+ */
+export const ValidatorDKGExtension = {
+    typeUrl: "/sparkdream.shield.v1.ValidatorDKGExtension",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validatorAddress.length !== 0) {
+            writer.uint32(10).bytes(message.validatorAddress);
+        }
+        if (message.extension !== undefined) {
+            DKGVoteExtension.encode(message.extension, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseValidatorDKGExtension();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorAddress = reader.bytes();
+                    break;
+                case 2:
+                    message.extension = DKGVoteExtension.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseValidatorDKGExtension();
+        message.validatorAddress = object.validatorAddress ?? new Uint8Array();
+        message.extension = object.extension !== undefined && object.extension !== null ? DKGVoteExtension.fromPartial(object.extension) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseValidatorDKGExtension();
+        if (object.validator_address !== undefined && object.validator_address !== null) {
+            message.validatorAddress = bytesFromBase64(object.validator_address);
+        }
+        if (object.extension !== undefined && object.extension !== null) {
+            message.extension = DKGVoteExtension.fromAmino(object.extension);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.validator_address = message.validatorAddress ? base64FromBytes(message.validatorAddress) : undefined;
+        obj.extension = message.extension ? DKGVoteExtension.toAmino(message.extension) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ValidatorDKGExtension.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ValidatorDKGExtension.decode(message.value);
+    },
+    toProto(message) {
+        return ValidatorDKGExtension.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.ValidatorDKGExtension",
+            value: ValidatorDKGExtension.encode(message).finish()
+        };
+    }
+};
+function createBaseVerificationKey() {
+    return {
+        circuitId: "",
+        vkBytes: new Uint8Array(),
+        description: ""
+    };
+}
+/**
+ * VerificationKey stores a ZK circuit verification key.
+ * @name VerificationKey
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.VerificationKey
+ */
+export const VerificationKey = {
+    typeUrl: "/sparkdream.shield.v1.VerificationKey",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.circuitId !== "") {
+            writer.uint32(10).string(message.circuitId);
+        }
+        if (message.vkBytes.length !== 0) {
+            writer.uint32(18).bytes(message.vkBytes);
+        }
+        if (message.description !== "") {
+            writer.uint32(26).string(message.description);
+        }
+        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 = createBaseVerificationKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.circuitId = reader.string();
+                    break;
+                case 2:
+                    message.vkBytes = reader.bytes();
+                    break;
+                case 3:
+                    message.description = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseVerificationKey();
+        message.circuitId = object.circuitId ?? "";
+        message.vkBytes = object.vkBytes ?? new Uint8Array();
+        message.description = object.description ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseVerificationKey();
+        if (object.circuit_id !== undefined && object.circuit_id !== null) {
+            message.circuitId = object.circuit_id;
+        }
+        if (object.vk_bytes !== undefined && object.vk_bytes !== null) {
+            message.vkBytes = bytesFromBase64(object.vk_bytes);
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.circuit_id = message.circuitId === "" ? undefined : message.circuitId;
+        obj.vk_bytes = message.vkBytes ? base64FromBytes(message.vkBytes) : undefined;
+        obj.description = message.description === "" ? undefined : message.description;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return VerificationKey.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return VerificationKey.decode(message.value);
+    },
+    toProto(message) {
+        return VerificationKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.VerificationKey",
+            value: VerificationKey.encode(message).finish()
+        };
+    }
+};
+function createBaseIdentityRateLimitEntry() {
+    return {
+        epoch: BigInt(0),
+        rateLimitNullifierHex: "",
+        count: BigInt(0)
+    };
+}
+/**
+ * IdentityRateLimitEntry is a genesis helper for exporting rate limit state.
+ * @name IdentityRateLimitEntry
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.IdentityRateLimitEntry
+ */
+export const IdentityRateLimitEntry = {
+    typeUrl: "/sparkdream.shield.v1.IdentityRateLimitEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epoch !== BigInt(0)) {
+            writer.uint32(8).uint64(message.epoch);
+        }
+        if (message.rateLimitNullifierHex !== "") {
+            writer.uint32(18).string(message.rateLimitNullifierHex);
+        }
+        if (message.count !== BigInt(0)) {
+            writer.uint32(24).uint64(message.count);
+        }
+        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 = createBaseIdentityRateLimitEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epoch = reader.uint64();
+                    break;
+                case 2:
+                    message.rateLimitNullifierHex = reader.string();
+                    break;
+                case 3:
+                    message.count = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseIdentityRateLimitEntry();
+        message.epoch = object.epoch !== undefined && object.epoch !== null ? BigInt(object.epoch.toString()) : BigInt(0);
+        message.rateLimitNullifierHex = object.rateLimitNullifierHex ?? "";
+        message.count = object.count !== undefined && object.count !== null ? BigInt(object.count.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseIdentityRateLimitEntry();
+        if (object.epoch !== undefined && object.epoch !== null) {
+            message.epoch = BigInt(object.epoch);
+        }
+        if (object.rate_limit_nullifier_hex !== undefined && object.rate_limit_nullifier_hex !== null) {
+            message.rateLimitNullifierHex = object.rate_limit_nullifier_hex;
+        }
+        if (object.count !== undefined && object.count !== null) {
+            message.count = BigInt(object.count);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch = message.epoch !== BigInt(0) ? message.epoch?.toString() : undefined;
+        obj.rate_limit_nullifier_hex = message.rateLimitNullifierHex === "" ? undefined : message.rateLimitNullifierHex;
+        obj.count = message.count !== BigInt(0) ? message.count?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return IdentityRateLimitEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return IdentityRateLimitEntry.decode(message.value);
+    },
+    toProto(message) {
+        return IdentityRateLimitEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.IdentityRateLimitEntry",
+            value: IdentityRateLimitEntry.encode(message).finish()
+        };
+    }
+};
+function createBaseTLEMissCounterEntry() {
+    return {
+        validatorAddress: "",
+        missCount: BigInt(0)
+    };
+}
+/**
+ * TLEMissCounterEntry is a genesis helper for exporting TLE miss counters.
+ * @name TLEMissCounterEntry
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.TLEMissCounterEntry
+ */
+export const TLEMissCounterEntry = {
+    typeUrl: "/sparkdream.shield.v1.TLEMissCounterEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validatorAddress !== "") {
+            writer.uint32(10).string(message.validatorAddress);
+        }
+        if (message.missCount !== BigInt(0)) {
+            writer.uint32(16).uint64(message.missCount);
+        }
+        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 = createBaseTLEMissCounterEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorAddress = reader.string();
+                    break;
+                case 2:
+                    message.missCount = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTLEMissCounterEntry();
+        message.validatorAddress = object.validatorAddress ?? "";
+        message.missCount = object.missCount !== undefined && object.missCount !== null ? BigInt(object.missCount.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTLEMissCounterEntry();
+        if (object.validator_address !== undefined && object.validator_address !== null) {
+            message.validatorAddress = object.validator_address;
+        }
+        if (object.miss_count !== undefined && object.miss_count !== null) {
+            message.missCount = BigInt(object.miss_count);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+        obj.miss_count = message.missCount !== BigInt(0) ? message.missCount?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return TLEMissCounterEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return TLEMissCounterEntry.decode(message.value);
+    },
+    toProto(message) {
+        return TLEMissCounterEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.TLEMissCounterEntry",
+            value: TLEMissCounterEntry.encode(message).finish()
+        };
+    }
+};