@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.8

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

@@ -0,0 +1,838 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { Any } from "../../../google/protobuf/any";
+import { ShieldedOpRegistration } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ * @name MsgUpdateParams
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/sparkdream.shield.v1.MsgUpdateParams",
+    aminoType: "sparkdream/x/shield/MsgUpdateParams",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, 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 = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateParams();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParams.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/shield/MsgUpdateParams",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+/**
+ * @name MsgUpdateParamsResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/sparkdream.shield.v1.MsgUpdateParamsResponse",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgShieldedExec() {
+    return {
+        submitter: "",
+        innerMessage: undefined,
+        proof: new Uint8Array(),
+        nullifier: new Uint8Array(),
+        rateLimitNullifier: new Uint8Array(),
+        merkleRoot: new Uint8Array(),
+        proofDomain: 0,
+        minTrustLevel: 0,
+        execMode: 0,
+        encryptedPayload: new Uint8Array(),
+        targetEpoch: BigInt(0)
+    };
+}
+/**
+ * MsgShieldedExec is the single entry point for all anonymous operations.
+ * @name MsgShieldedExec
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgShieldedExec
+ */
+export const MsgShieldedExec = {
+    typeUrl: "/sparkdream.shield.v1.MsgShieldedExec",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.submitter !== "") {
+            writer.uint32(10).string(message.submitter);
+        }
+        if (message.innerMessage !== undefined) {
+            Any.encode(message.innerMessage, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.proof.length !== 0) {
+            writer.uint32(26).bytes(message.proof);
+        }
+        if (message.nullifier.length !== 0) {
+            writer.uint32(34).bytes(message.nullifier);
+        }
+        if (message.rateLimitNullifier.length !== 0) {
+            writer.uint32(42).bytes(message.rateLimitNullifier);
+        }
+        if (message.merkleRoot.length !== 0) {
+            writer.uint32(50).bytes(message.merkleRoot);
+        }
+        if (message.proofDomain !== 0) {
+            writer.uint32(56).int32(message.proofDomain);
+        }
+        if (message.minTrustLevel !== 0) {
+            writer.uint32(64).uint32(message.minTrustLevel);
+        }
+        if (message.execMode !== 0) {
+            writer.uint32(72).int32(message.execMode);
+        }
+        if (message.encryptedPayload.length !== 0) {
+            writer.uint32(82).bytes(message.encryptedPayload);
+        }
+        if (message.targetEpoch !== BigInt(0)) {
+            writer.uint32(88).uint64(message.targetEpoch);
+        }
+        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 = createBaseMsgShieldedExec();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.submitter = reader.string();
+                    break;
+                case 2:
+                    message.innerMessage = Any.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.proof = reader.bytes();
+                    break;
+                case 4:
+                    message.nullifier = reader.bytes();
+                    break;
+                case 5:
+                    message.rateLimitNullifier = reader.bytes();
+                    break;
+                case 6:
+                    message.merkleRoot = reader.bytes();
+                    break;
+                case 7:
+                    message.proofDomain = reader.int32();
+                    break;
+                case 8:
+                    message.minTrustLevel = reader.uint32();
+                    break;
+                case 9:
+                    message.execMode = reader.int32();
+                    break;
+                case 10:
+                    message.encryptedPayload = reader.bytes();
+                    break;
+                case 11:
+                    message.targetEpoch = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgShieldedExec();
+        message.submitter = object.submitter ?? "";
+        message.innerMessage = object.innerMessage !== undefined && object.innerMessage !== null ? Any.fromPartial(object.innerMessage) : undefined;
+        message.proof = object.proof ?? new Uint8Array();
+        message.nullifier = object.nullifier ?? new Uint8Array();
+        message.rateLimitNullifier = object.rateLimitNullifier ?? new Uint8Array();
+        message.merkleRoot = object.merkleRoot ?? new Uint8Array();
+        message.proofDomain = object.proofDomain ?? 0;
+        message.minTrustLevel = object.minTrustLevel ?? 0;
+        message.execMode = object.execMode ?? 0;
+        message.encryptedPayload = object.encryptedPayload ?? new Uint8Array();
+        message.targetEpoch = object.targetEpoch !== undefined && object.targetEpoch !== null ? BigInt(object.targetEpoch.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgShieldedExec();
+        if (object.submitter !== undefined && object.submitter !== null) {
+            message.submitter = object.submitter;
+        }
+        if (object.inner_message !== undefined && object.inner_message !== null) {
+            message.innerMessage = Any.fromAmino(object.inner_message);
+        }
+        if (object.proof !== undefined && object.proof !== null) {
+            message.proof = bytesFromBase64(object.proof);
+        }
+        if (object.nullifier !== undefined && object.nullifier !== null) {
+            message.nullifier = bytesFromBase64(object.nullifier);
+        }
+        if (object.rate_limit_nullifier !== undefined && object.rate_limit_nullifier !== null) {
+            message.rateLimitNullifier = bytesFromBase64(object.rate_limit_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.exec_mode !== undefined && object.exec_mode !== null) {
+            message.execMode = object.exec_mode;
+        }
+        if (object.encrypted_payload !== undefined && object.encrypted_payload !== null) {
+            message.encryptedPayload = bytesFromBase64(object.encrypted_payload);
+        }
+        if (object.target_epoch !== undefined && object.target_epoch !== null) {
+            message.targetEpoch = BigInt(object.target_epoch);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.submitter = message.submitter === "" ? undefined : message.submitter;
+        obj.inner_message = message.innerMessage ? Any.toAmino(message.innerMessage) : undefined;
+        obj.proof = message.proof ? base64FromBytes(message.proof) : undefined;
+        obj.nullifier = message.nullifier ? base64FromBytes(message.nullifier) : undefined;
+        obj.rate_limit_nullifier = message.rateLimitNullifier ? base64FromBytes(message.rateLimitNullifier) : 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.exec_mode = message.execMode === 0 ? undefined : message.execMode;
+        obj.encrypted_payload = message.encryptedPayload ? base64FromBytes(message.encryptedPayload) : undefined;
+        obj.target_epoch = message.targetEpoch !== BigInt(0) ? message.targetEpoch?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgShieldedExec.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgShieldedExec.decode(message.value);
+    },
+    toProto(message) {
+        return MsgShieldedExec.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgShieldedExec",
+            value: MsgShieldedExec.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgShieldedExecResponse() {
+    return {
+        innerResponse: undefined,
+        pendingOpId: BigInt(0)
+    };
+}
+/**
+ * @name MsgShieldedExecResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgShieldedExecResponse
+ */
+export const MsgShieldedExecResponse = {
+    typeUrl: "/sparkdream.shield.v1.MsgShieldedExecResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.innerResponse !== undefined) {
+            Any.encode(message.innerResponse, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pendingOpId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.pendingOpId);
+        }
+        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 = createBaseMsgShieldedExecResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.innerResponse = Any.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.pendingOpId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgShieldedExecResponse();
+        message.innerResponse = object.innerResponse !== undefined && object.innerResponse !== null ? Any.fromPartial(object.innerResponse) : undefined;
+        message.pendingOpId = object.pendingOpId !== undefined && object.pendingOpId !== null ? BigInt(object.pendingOpId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgShieldedExecResponse();
+        if (object.inner_response !== undefined && object.inner_response !== null) {
+            message.innerResponse = Any.fromAmino(object.inner_response);
+        }
+        if (object.pending_op_id !== undefined && object.pending_op_id !== null) {
+            message.pendingOpId = BigInt(object.pending_op_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.inner_response = message.innerResponse ? Any.toAmino(message.innerResponse) : undefined;
+        obj.pending_op_id = message.pendingOpId !== BigInt(0) ? message.pendingOpId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgShieldedExecResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgShieldedExecResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgShieldedExecResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgShieldedExecResponse",
+            value: MsgShieldedExecResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgTriggerDkg() {
+    return {
+        authority: "",
+        thresholdNumerator: BigInt(0),
+        thresholdDenominator: BigInt(0)
+    };
+}
+/**
+ * MsgTriggerDkg manually triggers a new DKG ceremony (governance-gated).
+ * @name MsgTriggerDkg
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgTriggerDkg
+ */
+export const MsgTriggerDkg = {
+    typeUrl: "/sparkdream.shield.v1.MsgTriggerDkg",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.thresholdNumerator !== BigInt(0)) {
+            writer.uint32(16).uint64(message.thresholdNumerator);
+        }
+        if (message.thresholdDenominator !== BigInt(0)) {
+            writer.uint32(24).uint64(message.thresholdDenominator);
+        }
+        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 = createBaseMsgTriggerDkg();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.thresholdNumerator = reader.uint64();
+                    break;
+                case 3:
+                    message.thresholdDenominator = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgTriggerDkg();
+        message.authority = object.authority ?? "";
+        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);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgTriggerDkg();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        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);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.threshold_numerator = message.thresholdNumerator !== BigInt(0) ? message.thresholdNumerator?.toString() : undefined;
+        obj.threshold_denominator = message.thresholdDenominator !== BigInt(0) ? message.thresholdDenominator?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgTriggerDkg.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgTriggerDkg.decode(message.value);
+    },
+    toProto(message) {
+        return MsgTriggerDkg.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgTriggerDkg",
+            value: MsgTriggerDkg.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgTriggerDkgResponse() {
+    return {};
+}
+/**
+ * @name MsgTriggerDkgResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgTriggerDkgResponse
+ */
+export const MsgTriggerDkgResponse = {
+    typeUrl: "/sparkdream.shield.v1.MsgTriggerDkgResponse",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseMsgTriggerDkgResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgTriggerDkgResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgTriggerDkgResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgTriggerDkgResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgTriggerDkgResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgTriggerDkgResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgTriggerDkgResponse",
+            value: MsgTriggerDkgResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRegisterShieldedOp() {
+    return {
+        authority: "",
+        registration: ShieldedOpRegistration.fromPartial({})
+    };
+}
+/**
+ * MsgRegisterShieldedOp registers or updates a shielded operation (governance-gated).
+ * @name MsgRegisterShieldedOp
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgRegisterShieldedOp
+ */
+export const MsgRegisterShieldedOp = {
+    typeUrl: "/sparkdream.shield.v1.MsgRegisterShieldedOp",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.registration !== undefined) {
+            ShieldedOpRegistration.encode(message.registration, 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 = createBaseMsgRegisterShieldedOp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.registration = ShieldedOpRegistration.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRegisterShieldedOp();
+        message.authority = object.authority ?? "";
+        message.registration = object.registration !== undefined && object.registration !== null ? ShieldedOpRegistration.fromPartial(object.registration) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRegisterShieldedOp();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.registration !== undefined && object.registration !== null) {
+            message.registration = ShieldedOpRegistration.fromAmino(object.registration);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.registration = message.registration ? ShieldedOpRegistration.toAmino(message.registration) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRegisterShieldedOp.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRegisterShieldedOp.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRegisterShieldedOp.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgRegisterShieldedOp",
+            value: MsgRegisterShieldedOp.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRegisterShieldedOpResponse() {
+    return {};
+}
+/**
+ * @name MsgRegisterShieldedOpResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgRegisterShieldedOpResponse
+ */
+export const MsgRegisterShieldedOpResponse = {
+    typeUrl: "/sparkdream.shield.v1.MsgRegisterShieldedOpResponse",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseMsgRegisterShieldedOpResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRegisterShieldedOpResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRegisterShieldedOpResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRegisterShieldedOpResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRegisterShieldedOpResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRegisterShieldedOpResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgRegisterShieldedOpResponse",
+            value: MsgRegisterShieldedOpResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgDeregisterShieldedOp() {
+    return {
+        authority: "",
+        messageTypeUrl: ""
+    };
+}
+/**
+ * MsgDeregisterShieldedOp fully removes a shielded operation registration (governance-gated).
+ * @name MsgDeregisterShieldedOp
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgDeregisterShieldedOp
+ */
+export const MsgDeregisterShieldedOp = {
+    typeUrl: "/sparkdream.shield.v1.MsgDeregisterShieldedOp",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.messageTypeUrl !== "") {
+            writer.uint32(18).string(message.messageTypeUrl);
+        }
+        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 = createBaseMsgDeregisterShieldedOp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.messageTypeUrl = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgDeregisterShieldedOp();
+        message.authority = object.authority ?? "";
+        message.messageTypeUrl = object.messageTypeUrl ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgDeregisterShieldedOp();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.message_type_url !== undefined && object.message_type_url !== null) {
+            message.messageTypeUrl = object.message_type_url;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.message_type_url = message.messageTypeUrl === "" ? undefined : message.messageTypeUrl;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgDeregisterShieldedOp.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgDeregisterShieldedOp.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeregisterShieldedOp.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgDeregisterShieldedOp",
+            value: MsgDeregisterShieldedOp.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgDeregisterShieldedOpResponse() {
+    return {};
+}
+/**
+ * @name MsgDeregisterShieldedOpResponse
+ * @package sparkdream.shield.v1
+ * @see proto type: sparkdream.shield.v1.MsgDeregisterShieldedOpResponse
+ */
+export const MsgDeregisterShieldedOpResponse = {
+    typeUrl: "/sparkdream.shield.v1.MsgDeregisterShieldedOpResponse",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseMsgDeregisterShieldedOpResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgDeregisterShieldedOpResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgDeregisterShieldedOpResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgDeregisterShieldedOpResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgDeregisterShieldedOpResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeregisterShieldedOpResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.shield.v1.MsgDeregisterShieldedOpResponse",
+            value: MsgDeregisterShieldedOpResponse.encode(message).finish()
+        };
+    }
+};