@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.18

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

@@ -0,0 +1,2124 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { ServiceTypeConfig } from "./service_type_config";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams updates module-wide params. Authority = x/gov.
+ * @name MsgUpdateParams
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/sparkdream.service.v1.MsgUpdateParams",
+    aminoType: "sparkdream/x/service/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/service/MsgUpdateParams",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+/**
+ * @name MsgUpdateParamsResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/sparkdream.service.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.service.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateServiceTypeConfig() {
+    return {
+        authority: "",
+        config: ServiceTypeConfig.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateServiceTypeConfig creates, updates, or disables a
+ * ServiceTypeConfig entry. Authority = x/gov. See §3.2 for validation.
+ * @name MsgUpdateServiceTypeConfig
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUpdateServiceTypeConfig
+ */
+export const MsgUpdateServiceTypeConfig = {
+    typeUrl: "/sparkdream.service.v1.MsgUpdateServiceTypeConfig",
+    aminoType: "sparkdream/x/service/MsgUpdateServiceTypeConfig",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.config !== undefined) {
+            ServiceTypeConfig.encode(message.config, 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 = createBaseMsgUpdateServiceTypeConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.config = ServiceTypeConfig.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateServiceTypeConfig();
+        message.authority = object.authority ?? "";
+        message.config = object.config !== undefined && object.config !== null ? ServiceTypeConfig.fromPartial(object.config) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateServiceTypeConfig();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.config !== undefined && object.config !== null) {
+            message.config = ServiceTypeConfig.fromAmino(object.config);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.config = message.config ? ServiceTypeConfig.toAmino(message.config) : ServiceTypeConfig.toAmino(ServiceTypeConfig.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateServiceTypeConfig.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgUpdateServiceTypeConfig",
+            value: MsgUpdateServiceTypeConfig.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateServiceTypeConfig.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateServiceTypeConfig.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgUpdateServiceTypeConfig",
+            value: MsgUpdateServiceTypeConfig.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateServiceTypeConfigResponse() {
+    return {};
+}
+/**
+ * @name MsgUpdateServiceTypeConfigResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUpdateServiceTypeConfigResponse
+ */
+export const MsgUpdateServiceTypeConfigResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgUpdateServiceTypeConfigResponse",
+    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 = createBaseMsgUpdateServiceTypeConfigResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateServiceTypeConfigResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateServiceTypeConfigResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateServiceTypeConfigResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateServiceTypeConfigResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateServiceTypeConfigResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgUpdateServiceTypeConfigResponse",
+            value: MsgUpdateServiceTypeConfigResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRegisterOperator() {
+    return {
+        creator: "",
+        serviceType: "",
+        controller: "",
+        bondAmount: "",
+        metadata: new Uint8Array()
+    };
+}
+/**
+ * MsgRegisterOperator creates a new operator record. MUST be signed by
+ * `creator` directly (msg-server checks `creator == tx_signer[0]`); not
+ * delegable via x/session or x/authz (§5.1).
+ * @name MsgRegisterOperator
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgRegisterOperator
+ */
+export const MsgRegisterOperator = {
+    typeUrl: "/sparkdream.service.v1.MsgRegisterOperator",
+    aminoType: "sparkdream/x/service/MsgRegisterOperator",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.controller !== "") {
+            writer.uint32(26).string(message.controller);
+        }
+        if (message.bondAmount !== "") {
+            writer.uint32(34).string(message.bondAmount);
+        }
+        if (message.metadata.length !== 0) {
+            writer.uint32(42).bytes(message.metadata);
+        }
+        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 = createBaseMsgRegisterOperator();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.controller = reader.string();
+                    break;
+                case 4:
+                    message.bondAmount = reader.string();
+                    break;
+                case 5:
+                    message.metadata = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRegisterOperator();
+        message.creator = object.creator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.controller = object.controller ?? "";
+        message.bondAmount = object.bondAmount ?? "";
+        message.metadata = object.metadata ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRegisterOperator();
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.controller !== undefined && object.controller !== null) {
+            message.controller = object.controller;
+        }
+        if (object.bond_amount !== undefined && object.bond_amount !== null) {
+            message.bondAmount = object.bond_amount;
+        }
+        if (object.metadata !== undefined && object.metadata !== null) {
+            message.metadata = bytesFromBase64(object.metadata);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.controller = message.controller === "" ? undefined : message.controller;
+        obj.bond_amount = message.bondAmount === "" ? undefined : message.bondAmount;
+        obj.metadata = message.metadata ? base64FromBytes(message.metadata) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRegisterOperator.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgRegisterOperator",
+            value: MsgRegisterOperator.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRegisterOperator.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRegisterOperator.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgRegisterOperator",
+            value: MsgRegisterOperator.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRegisterOperatorResponse() {
+    return {};
+}
+/**
+ * @name MsgRegisterOperatorResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgRegisterOperatorResponse
+ */
+export const MsgRegisterOperatorResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgRegisterOperatorResponse",
+    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 = createBaseMsgRegisterOperatorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRegisterOperatorResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRegisterOperatorResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRegisterOperatorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRegisterOperatorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRegisterOperatorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgRegisterOperatorResponse",
+            value: MsgRegisterOperatorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateMetadata() {
+    return {
+        operator: "",
+        serviceType: "",
+        newMetadata: new Uint8Array()
+    };
+}
+/**
+ * MsgUpdateMetadata updates the operator's opaque metadata blob.
+ * @name MsgUpdateMetadata
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUpdateMetadata
+ */
+export const MsgUpdateMetadata = {
+    typeUrl: "/sparkdream.service.v1.MsgUpdateMetadata",
+    aminoType: "sparkdream/x/service/MsgUpdateMetadata",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operator !== "") {
+            writer.uint32(10).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.newMetadata.length !== 0) {
+            writer.uint32(26).bytes(message.newMetadata);
+        }
+        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 = createBaseMsgUpdateMetadata();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operator = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.newMetadata = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateMetadata();
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.newMetadata = object.newMetadata ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateMetadata();
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.new_metadata !== undefined && object.new_metadata !== null) {
+            message.newMetadata = bytesFromBase64(object.new_metadata);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.new_metadata = message.newMetadata ? base64FromBytes(message.newMetadata) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateMetadata.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgUpdateMetadata",
+            value: MsgUpdateMetadata.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateMetadata.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateMetadata.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgUpdateMetadata",
+            value: MsgUpdateMetadata.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateMetadataResponse() {
+    return {};
+}
+/**
+ * @name MsgUpdateMetadataResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUpdateMetadataResponse
+ */
+export const MsgUpdateMetadataResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgUpdateMetadataResponse",
+    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 = createBaseMsgUpdateMetadataResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateMetadataResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateMetadataResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateMetadataResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateMetadataResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateMetadataResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgUpdateMetadataResponse",
+            value: MsgUpdateMetadataResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUnbondOperator() {
+    return {
+        operator: "",
+        serviceType: ""
+    };
+}
+/**
+ * MsgUnbondOperator transitions ACTIVE | UNDERFUNDED → UNBONDING and
+ * starts the unbonding clock (§3.5). MUST be signed by `operator`
+ * directly (not delegable).
+ * @name MsgUnbondOperator
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUnbondOperator
+ */
+export const MsgUnbondOperator = {
+    typeUrl: "/sparkdream.service.v1.MsgUnbondOperator",
+    aminoType: "sparkdream/x/service/MsgUnbondOperator",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operator !== "") {
+            writer.uint32(10).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        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 = createBaseMsgUnbondOperator();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operator = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUnbondOperator();
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUnbondOperator();
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUnbondOperator.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgUnbondOperator",
+            value: MsgUnbondOperator.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUnbondOperator.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUnbondOperator.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgUnbondOperator",
+            value: MsgUnbondOperator.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUnbondOperatorResponse() {
+    return {};
+}
+/**
+ * @name MsgUnbondOperatorResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgUnbondOperatorResponse
+ */
+export const MsgUnbondOperatorResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgUnbondOperatorResponse",
+    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 = createBaseMsgUnbondOperatorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUnbondOperatorResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUnbondOperatorResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUnbondOperatorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUnbondOperatorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUnbondOperatorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgUnbondOperatorResponse",
+            value: MsgUnbondOperatorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgClaimUnbondedBond() {
+    return {
+        operator: "",
+        serviceType: ""
+    };
+}
+/**
+ * MsgClaimUnbondedBond completes unbonding, returns bond, and archives
+ * the record as RETIRED (§3.5).
+ * @name MsgClaimUnbondedBond
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgClaimUnbondedBond
+ */
+export const MsgClaimUnbondedBond = {
+    typeUrl: "/sparkdream.service.v1.MsgClaimUnbondedBond",
+    aminoType: "sparkdream/x/service/MsgClaimUnbondedBond",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operator !== "") {
+            writer.uint32(10).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        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 = createBaseMsgClaimUnbondedBond();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operator = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgClaimUnbondedBond();
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgClaimUnbondedBond();
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClaimUnbondedBond.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgClaimUnbondedBond",
+            value: MsgClaimUnbondedBond.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgClaimUnbondedBond.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClaimUnbondedBond.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgClaimUnbondedBond",
+            value: MsgClaimUnbondedBond.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgClaimUnbondedBondResponse() {
+    return {};
+}
+/**
+ * @name MsgClaimUnbondedBondResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgClaimUnbondedBondResponse
+ */
+export const MsgClaimUnbondedBondResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgClaimUnbondedBondResponse",
+    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 = createBaseMsgClaimUnbondedBondResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgClaimUnbondedBondResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgClaimUnbondedBondResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClaimUnbondedBondResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgClaimUnbondedBondResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClaimUnbondedBondResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgClaimUnbondedBondResponse",
+            value: MsgClaimUnbondedBondResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgTopUpBond() {
+    return {
+        operator: "",
+        serviceType: "",
+        additionalBondAmount: ""
+    };
+}
+/**
+ * MsgTopUpBond adds SPARK to an operator's bond. Clears UNDERFUNDED if
+ * the new bond ≥ min_bond.
+ * @name MsgTopUpBond
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgTopUpBond
+ */
+export const MsgTopUpBond = {
+    typeUrl: "/sparkdream.service.v1.MsgTopUpBond",
+    aminoType: "sparkdream/x/service/MsgTopUpBond",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operator !== "") {
+            writer.uint32(10).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.additionalBondAmount !== "") {
+            writer.uint32(26).string(message.additionalBondAmount);
+        }
+        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 = createBaseMsgTopUpBond();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operator = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.additionalBondAmount = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgTopUpBond();
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.additionalBondAmount = object.additionalBondAmount ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgTopUpBond();
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.additional_bond_amount !== undefined && object.additional_bond_amount !== null) {
+            message.additionalBondAmount = object.additional_bond_amount;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.additional_bond_amount = message.additionalBondAmount === "" ? undefined : message.additionalBondAmount;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgTopUpBond.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgTopUpBond",
+            value: MsgTopUpBond.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgTopUpBond.decode(message.value);
+    },
+    toProto(message) {
+        return MsgTopUpBond.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgTopUpBond",
+            value: MsgTopUpBond.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgTopUpBondResponse() {
+    return {};
+}
+/**
+ * @name MsgTopUpBondResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgTopUpBondResponse
+ */
+export const MsgTopUpBondResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgTopUpBondResponse",
+    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 = createBaseMsgTopUpBondResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgTopUpBondResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgTopUpBondResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgTopUpBondResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgTopUpBondResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgTopUpBondResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgTopUpBondResponse",
+            value: MsgTopUpBondResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgReportOperator() {
+    return {
+        reporter: "",
+        operator: "",
+        serviceType: "",
+        reason: ""
+    };
+}
+/**
+ * MsgReportOperator files a new report. Reporter posts `report_deposit`
+ * escrow at filing (§3.4.6). Rate-limited per
+ * (reporter, operator, service_type).
+ * @name MsgReportOperator
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgReportOperator
+ */
+export const MsgReportOperator = {
+    typeUrl: "/sparkdream.service.v1.MsgReportOperator",
+    aminoType: "sparkdream/x/service/MsgReportOperator",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.reporter !== "") {
+            writer.uint32(10).string(message.reporter);
+        }
+        if (message.operator !== "") {
+            writer.uint32(18).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(26).string(message.serviceType);
+        }
+        if (message.reason !== "") {
+            writer.uint32(34).string(message.reason);
+        }
+        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 = createBaseMsgReportOperator();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reporter = reader.string();
+                    break;
+                case 2:
+                    message.operator = reader.string();
+                    break;
+                case 3:
+                    message.serviceType = reader.string();
+                    break;
+                case 4:
+                    message.reason = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgReportOperator();
+        message.reporter = object.reporter ?? "";
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.reason = object.reason ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgReportOperator();
+        if (object.reporter !== undefined && object.reporter !== null) {
+            message.reporter = object.reporter;
+        }
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.reporter = message.reporter === "" ? undefined : message.reporter;
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.reason = message.reason === "" ? undefined : message.reason;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgReportOperator.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgReportOperator",
+            value: MsgReportOperator.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgReportOperator.decode(message.value);
+    },
+    toProto(message) {
+        return MsgReportOperator.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgReportOperator",
+            value: MsgReportOperator.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgReportOperatorResponse() {
+    return {
+        reportId: BigInt(0)
+    };
+}
+/**
+ * @name MsgReportOperatorResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgReportOperatorResponse
+ */
+export const MsgReportOperatorResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgReportOperatorResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.reportId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.reportId);
+        }
+        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 = createBaseMsgReportOperatorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reportId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgReportOperatorResponse();
+        message.reportId = object.reportId !== undefined && object.reportId !== null ? BigInt(object.reportId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgReportOperatorResponse();
+        if (object.report_id !== undefined && object.report_id !== null) {
+            message.reportId = BigInt(object.report_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.report_id = message.reportId !== BigInt(0) ? message.reportId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgReportOperatorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgReportOperatorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgReportOperatorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgReportOperatorResponse",
+            value: MsgReportOperatorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgResolveReport() {
+    return {
+        controller: "",
+        reportId: BigInt(0),
+        verdict: 0,
+        slashBps: 0
+    };
+}
+/**
+ * MsgResolveReport is the controller's verdict on a PENDING report
+ * (§5.2). For ESCALATE_TO_JURY, the controller's `slash_bps` is stored
+ * as the report's `proposed_slash_bps` upper bound.
+ * @name MsgResolveReport
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgResolveReport
+ */
+export const MsgResolveReport = {
+    typeUrl: "/sparkdream.service.v1.MsgResolveReport",
+    aminoType: "sparkdream/x/service/MsgResolveReport",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.controller !== "") {
+            writer.uint32(10).string(message.controller);
+        }
+        if (message.reportId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.reportId);
+        }
+        if (message.verdict !== 0) {
+            writer.uint32(24).int32(message.verdict);
+        }
+        if (message.slashBps !== 0) {
+            writer.uint32(32).uint32(message.slashBps);
+        }
+        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 = createBaseMsgResolveReport();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.controller = reader.string();
+                    break;
+                case 2:
+                    message.reportId = reader.uint64();
+                    break;
+                case 3:
+                    message.verdict = reader.int32();
+                    break;
+                case 4:
+                    message.slashBps = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgResolveReport();
+        message.controller = object.controller ?? "";
+        message.reportId = object.reportId !== undefined && object.reportId !== null ? BigInt(object.reportId.toString()) : BigInt(0);
+        message.verdict = object.verdict ?? 0;
+        message.slashBps = object.slashBps ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgResolveReport();
+        if (object.controller !== undefined && object.controller !== null) {
+            message.controller = object.controller;
+        }
+        if (object.report_id !== undefined && object.report_id !== null) {
+            message.reportId = BigInt(object.report_id);
+        }
+        if (object.verdict !== undefined && object.verdict !== null) {
+            message.verdict = object.verdict;
+        }
+        if (object.slash_bps !== undefined && object.slash_bps !== null) {
+            message.slashBps = object.slash_bps;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.controller = message.controller === "" ? undefined : message.controller;
+        obj.report_id = message.reportId !== BigInt(0) ? message.reportId?.toString() : undefined;
+        obj.verdict = message.verdict === 0 ? undefined : message.verdict;
+        obj.slash_bps = message.slashBps === 0 ? undefined : message.slashBps;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgResolveReport.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgResolveReport",
+            value: MsgResolveReport.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgResolveReport.decode(message.value);
+    },
+    toProto(message) {
+        return MsgResolveReport.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgResolveReport",
+            value: MsgResolveReport.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgResolveReportResponse() {
+    return {};
+}
+/**
+ * @name MsgResolveReportResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgResolveReportResponse
+ */
+export const MsgResolveReportResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgResolveReportResponse",
+    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 = createBaseMsgResolveReportResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgResolveReportResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgResolveReportResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgResolveReportResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgResolveReportResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgResolveReportResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgResolveReportResponse",
+            value: MsgResolveReportResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgContestSlash() {
+    return {
+        operator: "",
+        serviceType: "",
+        reportId: BigInt(0)
+    };
+}
+/**
+ * MsgContestSlash escalates a RESOLVED_T1 report to the jury within
+ * the contest window (§5.2). Escrow returns to bond eagerly.
+ * @name MsgContestSlash
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgContestSlash
+ */
+export const MsgContestSlash = {
+    typeUrl: "/sparkdream.service.v1.MsgContestSlash",
+    aminoType: "sparkdream/x/service/MsgContestSlash",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operator !== "") {
+            writer.uint32(10).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.reportId !== BigInt(0)) {
+            writer.uint32(24).uint64(message.reportId);
+        }
+        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 = createBaseMsgContestSlash();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operator = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.reportId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgContestSlash();
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.reportId = object.reportId !== undefined && object.reportId !== null ? BigInt(object.reportId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgContestSlash();
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.report_id !== undefined && object.report_id !== null) {
+            message.reportId = BigInt(object.report_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.report_id = message.reportId !== BigInt(0) ? message.reportId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgContestSlash.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgContestSlash",
+            value: MsgContestSlash.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgContestSlash.decode(message.value);
+    },
+    toProto(message) {
+        return MsgContestSlash.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgContestSlash",
+            value: MsgContestSlash.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgContestSlashResponse() {
+    return {};
+}
+/**
+ * @name MsgContestSlashResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgContestSlashResponse
+ */
+export const MsgContestSlashResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgContestSlashResponse",
+    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 = createBaseMsgContestSlashResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgContestSlashResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgContestSlashResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgContestSlashResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgContestSlashResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgContestSlashResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgContestSlashResponse",
+            value: MsgContestSlashResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgResolveReportByJury() {
+    return {
+        juryAuthority: "",
+        reportId: BigInt(0),
+        verdict: 0,
+        slashBps: 0,
+        dissolve: false
+    };
+}
+/**
+ * MsgResolveReportByJury is the only path to apply a tier-2 slash.
+ * Signer is the x/rep module account (§5.2 + §6.2); rejected from any
+ * other signer with ErrUnauthorizedJuryAuthority.
+ * @name MsgResolveReportByJury
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgResolveReportByJury
+ */
+export const MsgResolveReportByJury = {
+    typeUrl: "/sparkdream.service.v1.MsgResolveReportByJury",
+    aminoType: "sparkdream/x/service/MsgResolveReportByJury",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.juryAuthority !== "") {
+            writer.uint32(10).string(message.juryAuthority);
+        }
+        if (message.reportId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.reportId);
+        }
+        if (message.verdict !== 0) {
+            writer.uint32(24).int32(message.verdict);
+        }
+        if (message.slashBps !== 0) {
+            writer.uint32(32).uint32(message.slashBps);
+        }
+        if (message.dissolve === true) {
+            writer.uint32(40).bool(message.dissolve);
+        }
+        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 = createBaseMsgResolveReportByJury();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.juryAuthority = reader.string();
+                    break;
+                case 2:
+                    message.reportId = reader.uint64();
+                    break;
+                case 3:
+                    message.verdict = reader.int32();
+                    break;
+                case 4:
+                    message.slashBps = reader.uint32();
+                    break;
+                case 5:
+                    message.dissolve = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgResolveReportByJury();
+        message.juryAuthority = object.juryAuthority ?? "";
+        message.reportId = object.reportId !== undefined && object.reportId !== null ? BigInt(object.reportId.toString()) : BigInt(0);
+        message.verdict = object.verdict ?? 0;
+        message.slashBps = object.slashBps ?? 0;
+        message.dissolve = object.dissolve ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgResolveReportByJury();
+        if (object.jury_authority !== undefined && object.jury_authority !== null) {
+            message.juryAuthority = object.jury_authority;
+        }
+        if (object.report_id !== undefined && object.report_id !== null) {
+            message.reportId = BigInt(object.report_id);
+        }
+        if (object.verdict !== undefined && object.verdict !== null) {
+            message.verdict = object.verdict;
+        }
+        if (object.slash_bps !== undefined && object.slash_bps !== null) {
+            message.slashBps = object.slash_bps;
+        }
+        if (object.dissolve !== undefined && object.dissolve !== null) {
+            message.dissolve = object.dissolve;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.jury_authority = message.juryAuthority === "" ? undefined : message.juryAuthority;
+        obj.report_id = message.reportId !== BigInt(0) ? message.reportId?.toString() : undefined;
+        obj.verdict = message.verdict === 0 ? undefined : message.verdict;
+        obj.slash_bps = message.slashBps === 0 ? undefined : message.slashBps;
+        obj.dissolve = message.dissolve === false ? undefined : message.dissolve;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgResolveReportByJury.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgResolveReportByJury",
+            value: MsgResolveReportByJury.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgResolveReportByJury.decode(message.value);
+    },
+    toProto(message) {
+        return MsgResolveReportByJury.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgResolveReportByJury",
+            value: MsgResolveReportByJury.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgResolveReportByJuryResponse() {
+    return {};
+}
+/**
+ * @name MsgResolveReportByJuryResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgResolveReportByJuryResponse
+ */
+export const MsgResolveReportByJuryResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgResolveReportByJuryResponse",
+    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 = createBaseMsgResolveReportByJuryResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgResolveReportByJuryResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgResolveReportByJuryResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgResolveReportByJuryResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgResolveReportByJuryResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgResolveReportByJuryResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgResolveReportByJuryResponse",
+            value: MsgResolveReportByJuryResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgOpenControllerTransferCase() {
+    return {
+        opener: "",
+        operator: "",
+        serviceType: "",
+        proposedNewController: "",
+        reason: ""
+    };
+}
+/**
+ * MsgOpenControllerTransferCase opens a jury case to transfer the
+ * operator's controller to a new x/commons Group (§5.4). At most one
+ * open case per (operator, service_type).
+ * @name MsgOpenControllerTransferCase
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgOpenControllerTransferCase
+ */
+export const MsgOpenControllerTransferCase = {
+    typeUrl: "/sparkdream.service.v1.MsgOpenControllerTransferCase",
+    aminoType: "sparkdream/x/service/MsgOpenControllerTransferCase",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.opener !== "") {
+            writer.uint32(10).string(message.opener);
+        }
+        if (message.operator !== "") {
+            writer.uint32(18).string(message.operator);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(26).string(message.serviceType);
+        }
+        if (message.proposedNewController !== "") {
+            writer.uint32(34).string(message.proposedNewController);
+        }
+        if (message.reason !== "") {
+            writer.uint32(42).string(message.reason);
+        }
+        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 = createBaseMsgOpenControllerTransferCase();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.opener = reader.string();
+                    break;
+                case 2:
+                    message.operator = reader.string();
+                    break;
+                case 3:
+                    message.serviceType = reader.string();
+                    break;
+                case 4:
+                    message.proposedNewController = reader.string();
+                    break;
+                case 5:
+                    message.reason = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgOpenControllerTransferCase();
+        message.opener = object.opener ?? "";
+        message.operator = object.operator ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.proposedNewController = object.proposedNewController ?? "";
+        message.reason = object.reason ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgOpenControllerTransferCase();
+        if (object.opener !== undefined && object.opener !== null) {
+            message.opener = object.opener;
+        }
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = object.operator;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.proposed_new_controller !== undefined && object.proposed_new_controller !== null) {
+            message.proposedNewController = object.proposed_new_controller;
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.opener = message.opener === "" ? undefined : message.opener;
+        obj.operator = message.operator === "" ? undefined : message.operator;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.proposed_new_controller = message.proposedNewController === "" ? undefined : message.proposedNewController;
+        obj.reason = message.reason === "" ? undefined : message.reason;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgOpenControllerTransferCase.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgOpenControllerTransferCase",
+            value: MsgOpenControllerTransferCase.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgOpenControllerTransferCase.decode(message.value);
+    },
+    toProto(message) {
+        return MsgOpenControllerTransferCase.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgOpenControllerTransferCase",
+            value: MsgOpenControllerTransferCase.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgOpenControllerTransferCaseResponse() {
+    return {
+        juryCaseId: BigInt(0)
+    };
+}
+/**
+ * @name MsgOpenControllerTransferCaseResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgOpenControllerTransferCaseResponse
+ */
+export const MsgOpenControllerTransferCaseResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgOpenControllerTransferCaseResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.juryCaseId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.juryCaseId);
+        }
+        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 = createBaseMsgOpenControllerTransferCaseResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.juryCaseId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgOpenControllerTransferCaseResponse();
+        message.juryCaseId = object.juryCaseId !== undefined && object.juryCaseId !== null ? BigInt(object.juryCaseId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgOpenControllerTransferCaseResponse();
+        if (object.jury_case_id !== undefined && object.jury_case_id !== null) {
+            message.juryCaseId = BigInt(object.jury_case_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.jury_case_id = message.juryCaseId !== BigInt(0) ? message.juryCaseId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgOpenControllerTransferCaseResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgOpenControllerTransferCaseResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgOpenControllerTransferCaseResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgOpenControllerTransferCaseResponse",
+            value: MsgOpenControllerTransferCaseResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgFinalizeControllerTransfer() {
+    return {
+        juryAuthority: "",
+        juryCaseId: BigInt(0),
+        verdict: 0,
+        newController: ""
+    };
+}
+/**
+ * MsgFinalizeControllerTransfer applies the jury verdict (ACCEPT or
+ * REJECT) on a controller-transfer case. Signer is the x/rep module
+ * account (§5.4 + §6.2). Re-checks Group eligibility at apply time.
+ * @name MsgFinalizeControllerTransfer
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgFinalizeControllerTransfer
+ */
+export const MsgFinalizeControllerTransfer = {
+    typeUrl: "/sparkdream.service.v1.MsgFinalizeControllerTransfer",
+    aminoType: "sparkdream/x/service/MsgFinalizeControllerTransfer",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.juryAuthority !== "") {
+            writer.uint32(10).string(message.juryAuthority);
+        }
+        if (message.juryCaseId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.juryCaseId);
+        }
+        if (message.verdict !== 0) {
+            writer.uint32(24).int32(message.verdict);
+        }
+        if (message.newController !== "") {
+            writer.uint32(34).string(message.newController);
+        }
+        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 = createBaseMsgFinalizeControllerTransfer();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.juryAuthority = reader.string();
+                    break;
+                case 2:
+                    message.juryCaseId = reader.uint64();
+                    break;
+                case 3:
+                    message.verdict = reader.int32();
+                    break;
+                case 4:
+                    message.newController = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgFinalizeControllerTransfer();
+        message.juryAuthority = object.juryAuthority ?? "";
+        message.juryCaseId = object.juryCaseId !== undefined && object.juryCaseId !== null ? BigInt(object.juryCaseId.toString()) : BigInt(0);
+        message.verdict = object.verdict ?? 0;
+        message.newController = object.newController ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgFinalizeControllerTransfer();
+        if (object.jury_authority !== undefined && object.jury_authority !== null) {
+            message.juryAuthority = object.jury_authority;
+        }
+        if (object.jury_case_id !== undefined && object.jury_case_id !== null) {
+            message.juryCaseId = BigInt(object.jury_case_id);
+        }
+        if (object.verdict !== undefined && object.verdict !== null) {
+            message.verdict = object.verdict;
+        }
+        if (object.new_controller !== undefined && object.new_controller !== null) {
+            message.newController = object.new_controller;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.jury_authority = message.juryAuthority === "" ? undefined : message.juryAuthority;
+        obj.jury_case_id = message.juryCaseId !== BigInt(0) ? message.juryCaseId?.toString() : undefined;
+        obj.verdict = message.verdict === 0 ? undefined : message.verdict;
+        obj.new_controller = message.newController === "" ? undefined : message.newController;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgFinalizeControllerTransfer.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/service/MsgFinalizeControllerTransfer",
+            value: MsgFinalizeControllerTransfer.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgFinalizeControllerTransfer.decode(message.value);
+    },
+    toProto(message) {
+        return MsgFinalizeControllerTransfer.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgFinalizeControllerTransfer",
+            value: MsgFinalizeControllerTransfer.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgFinalizeControllerTransferResponse() {
+    return {};
+}
+/**
+ * @name MsgFinalizeControllerTransferResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.MsgFinalizeControllerTransferResponse
+ */
+export const MsgFinalizeControllerTransferResponse = {
+    typeUrl: "/sparkdream.service.v1.MsgFinalizeControllerTransferResponse",
+    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 = createBaseMsgFinalizeControllerTransferResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgFinalizeControllerTransferResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgFinalizeControllerTransferResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgFinalizeControllerTransferResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgFinalizeControllerTransferResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgFinalizeControllerTransferResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.MsgFinalizeControllerTransferResponse",
+            value: MsgFinalizeControllerTransferResponse.encode(message).finish()
+        };
+    }
+};