@sparkdreamnft/sparkdreamjs 0.0.44 → 0.0.46

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

@@ -508,7 +508,8 @@ function createBaseMsgAcceptInvitation() {
     return {
         invitee: "",
         invitationId: BigInt(0),
-        acceptedContentLicense: ""
+        acceptedContentLicense: "",
+        recoveryCommitment: new Uint8Array()
     };
 }
 /**
@@ -530,6 +531,9 @@ export const MsgAcceptInvitation = {
         if (message.acceptedContentLicense !== "") {
             writer.uint32(26).string(message.acceptedContentLicense);
         }
+        if (message.recoveryCommitment.length !== 0) {
+            writer.uint32(34).bytes(message.recoveryCommitment);
+        }
         return writer;
     },
     decode(input, length) {
@@ -548,6 +552,9 @@ export const MsgAcceptInvitation = {
                 case 3:
                     message.acceptedContentLicense = reader.string();
                     break;
+                case 4:
+                    message.recoveryCommitment = reader.bytes();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -560,6 +567,7 @@ export const MsgAcceptInvitation = {
         message.invitee = object.invitee ?? "";
         message.invitationId = object.invitationId !== undefined && object.invitationId !== null ? BigInt(object.invitationId.toString()) : BigInt(0);
         message.acceptedContentLicense = object.acceptedContentLicense ?? "";
+        message.recoveryCommitment = object.recoveryCommitment ?? new Uint8Array();
         return message;
     },
     fromAmino(object) {
@@ -573,6 +581,9 @@ export const MsgAcceptInvitation = {
         if (object.accepted_content_license !== undefined && object.accepted_content_license !== null) {
             message.acceptedContentLicense = object.accepted_content_license;
         }
+        if (object.recovery_commitment !== undefined && object.recovery_commitment !== null) {
+            message.recoveryCommitment = bytesFromBase64(object.recovery_commitment);
+        }
         return message;
     },
     toAmino(message) {
@@ -580,6 +591,7 @@ export const MsgAcceptInvitation = {
         obj.invitee = message.invitee === "" ? undefined : message.invitee;
         obj.invitation_id = message.invitationId !== BigInt(0) ? message.invitationId?.toString() : undefined;
         obj.accepted_content_license = message.acceptedContentLicense === "" ? undefined : message.acceptedContentLicense;
+        obj.recovery_commitment = message.recoveryCommitment ? base64FromBytes(message.recoveryCommitment) : undefined;
         return obj;
     },
     fromAminoMsg(object) {
@@ -9833,3 +9845,1876 @@ export const MsgReclaimInitiativeBountyResponse = {
         };
     }
 };
+function createBaseMsgRevokeInvitation() {
+    return {
+        inviter: "",
+        invitationId: BigInt(0)
+    };
+}
+/**
+ * MsgRevokeInvitation withdraws a PENDING invitation. Only the inviter may
+ * revoke; an accepted, expired or already-revoked invitation is rejected.
+ * @name MsgRevokeInvitation
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitation
+ */
+export const MsgRevokeInvitation = {
+    typeUrl: "/sparkdream.rep.v1.MsgRevokeInvitation",
+    aminoType: "sparkdream/x/rep/MsgRevokeInvitation",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.inviter !== "") {
+            writer.uint32(10).string(message.inviter);
+        }
+        if (message.invitationId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.invitationId);
+        }
+        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 = createBaseMsgRevokeInvitation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.inviter = reader.string();
+                    break;
+                case 2:
+                    message.invitationId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRevokeInvitation();
+        message.inviter = object.inviter ?? "";
+        message.invitationId = object.invitationId !== undefined && object.invitationId !== null ? BigInt(object.invitationId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRevokeInvitation();
+        if (object.inviter !== undefined && object.inviter !== null) {
+            message.inviter = object.inviter;
+        }
+        if (object.invitation_id !== undefined && object.invitation_id !== null) {
+            message.invitationId = BigInt(object.invitation_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.inviter = message.inviter === "" ? undefined : message.inviter;
+        obj.invitation_id = message.invitationId !== BigInt(0) ? message.invitationId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevokeInvitation.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgRevokeInvitation",
+            value: MsgRevokeInvitation.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRevokeInvitation.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevokeInvitation.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRevokeInvitation",
+            value: MsgRevokeInvitation.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRevokeInvitationResponse() {
+    return {};
+}
+/**
+ * MsgRevokeInvitationResponse defines the MsgRevokeInvitationResponse message.
+ * @name MsgRevokeInvitationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitationResponse
+ */
+export const MsgRevokeInvitationResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgRevokeInvitationResponse",
+    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 = createBaseMsgRevokeInvitationResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRevokeInvitationResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRevokeInvitationResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevokeInvitationResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRevokeInvitationResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevokeInvitationResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRevokeInvitationResponse",
+            value: MsgRevokeInvitationResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRequestMigration() {
+    return {
+        member: "",
+        newAddress: ""
+    };
+}
+/**
+ * MsgRequestMigration opens a KEY-path migration of the signer's identity to
+ * new_address (member key migration, docs/x-rep-spec.md). Refused while the
+ * key path is disabled, the member is zeroed or tombstoned, a member report
+ * against them is open, the cooldown or the rolling-window cap applies, a
+ * migration of equal or higher precedence is pending, or new_address is not
+ * fresh. The new address must accept with MsgAcceptMigration within
+ * migration_accept_window. No fee: safety actions pay gas only.
+ * @name MsgRequestMigration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRequestMigration
+ */
+export const MsgRequestMigration = {
+    typeUrl: "/sparkdream.rep.v1.MsgRequestMigration",
+    aminoType: "sparkdream/x/rep/MsgRequestMigration",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.member !== "") {
+            writer.uint32(10).string(message.member);
+        }
+        if (message.newAddress !== "") {
+            writer.uint32(18).string(message.newAddress);
+        }
+        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 = createBaseMsgRequestMigration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.member = reader.string();
+                    break;
+                case 2:
+                    message.newAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRequestMigration();
+        message.member = object.member ?? "";
+        message.newAddress = object.newAddress ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRequestMigration();
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.new_address !== undefined && object.new_address !== null) {
+            message.newAddress = object.new_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.new_address = message.newAddress === "" ? undefined : message.newAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRequestMigration.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgRequestMigration",
+            value: MsgRequestMigration.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRequestMigration.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRequestMigration.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRequestMigration",
+            value: MsgRequestMigration.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRequestMigrationResponse() {
+    return {
+        migrationId: BigInt(0)
+    };
+}
+/**
+ * MsgRequestMigrationResponse defines the MsgRequestMigrationResponse message.
+ * @name MsgRequestMigrationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRequestMigrationResponse
+ */
+export const MsgRequestMigrationResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgRequestMigrationResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.migrationId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.migrationId);
+        }
+        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 = createBaseMsgRequestMigrationResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.migrationId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRequestMigrationResponse();
+        message.migrationId = object.migrationId !== undefined && object.migrationId !== null ? BigInt(object.migrationId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRequestMigrationResponse();
+        if (object.migration_id !== undefined && object.migration_id !== null) {
+            message.migrationId = BigInt(object.migration_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.migration_id = message.migrationId !== BigInt(0) ? message.migrationId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRequestMigrationResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRequestMigrationResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRequestMigrationResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRequestMigrationResponse",
+            value: MsgRequestMigrationResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgAcceptMigration() {
+    return {
+        newAddress: "",
+        migrationId: BigInt(0)
+    };
+}
+/**
+ * MsgAcceptMigration is signed by the new address and completes every path
+ * (key, recovery, council): it proves control of the target so nobody
+ * migrates into a typo, starts the path's delay and enqueues finalization. A
+ * native multisig target multisigns it.
+ * @name MsgAcceptMigration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgAcceptMigration
+ */
+export const MsgAcceptMigration = {
+    typeUrl: "/sparkdream.rep.v1.MsgAcceptMigration",
+    aminoType: "sparkdream/x/rep/MsgAcceptMigration",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.newAddress !== "") {
+            writer.uint32(10).string(message.newAddress);
+        }
+        if (message.migrationId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.migrationId);
+        }
+        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 = createBaseMsgAcceptMigration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.newAddress = reader.string();
+                    break;
+                case 2:
+                    message.migrationId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgAcceptMigration();
+        message.newAddress = object.newAddress ?? "";
+        message.migrationId = object.migrationId !== undefined && object.migrationId !== null ? BigInt(object.migrationId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgAcceptMigration();
+        if (object.new_address !== undefined && object.new_address !== null) {
+            message.newAddress = object.new_address;
+        }
+        if (object.migration_id !== undefined && object.migration_id !== null) {
+            message.migrationId = BigInt(object.migration_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.new_address = message.newAddress === "" ? undefined : message.newAddress;
+        obj.migration_id = message.migrationId !== BigInt(0) ? message.migrationId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgAcceptMigration.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgAcceptMigration",
+            value: MsgAcceptMigration.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgAcceptMigration.decode(message.value);
+    },
+    toProto(message) {
+        return MsgAcceptMigration.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgAcceptMigration",
+            value: MsgAcceptMigration.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgAcceptMigrationResponse() {
+    return {};
+}
+/**
+ * MsgAcceptMigrationResponse defines the MsgAcceptMigrationResponse message.
+ * @name MsgAcceptMigrationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgAcceptMigrationResponse
+ */
+export const MsgAcceptMigrationResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgAcceptMigrationResponse",
+    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 = createBaseMsgAcceptMigrationResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgAcceptMigrationResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgAcceptMigrationResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgAcceptMigrationResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgAcceptMigrationResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgAcceptMigrationResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgAcceptMigrationResponse",
+            value: MsgAcceptMigrationResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCancelMigration() {
+    return {
+        signer: "",
+        migrationId: BigInt(0)
+    };
+}
+/**
+ * MsgCancelMigration cancels a pending migration. The old or new address may
+ * cancel a KEY migration; the Commons HR committee policy may cancel KEY and
+ * COUNCIL migrations; governance may cancel any path and is the only
+ * authority over a RECOVERY migration.
+ * @name MsgCancelMigration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgCancelMigration
+ */
+export const MsgCancelMigration = {
+    typeUrl: "/sparkdream.rep.v1.MsgCancelMigration",
+    aminoType: "sparkdream/x/rep/MsgCancelMigration",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.migrationId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.migrationId);
+        }
+        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 = createBaseMsgCancelMigration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.migrationId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCancelMigration();
+        message.signer = object.signer ?? "";
+        message.migrationId = object.migrationId !== undefined && object.migrationId !== null ? BigInt(object.migrationId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCancelMigration();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.migration_id !== undefined && object.migration_id !== null) {
+            message.migrationId = BigInt(object.migration_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.migration_id = message.migrationId !== BigInt(0) ? message.migrationId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCancelMigration.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgCancelMigration",
+            value: MsgCancelMigration.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgCancelMigration.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCancelMigration.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgCancelMigration",
+            value: MsgCancelMigration.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCancelMigrationResponse() {
+    return {};
+}
+/**
+ * MsgCancelMigrationResponse defines the MsgCancelMigrationResponse message.
+ * @name MsgCancelMigrationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgCancelMigrationResponse
+ */
+export const MsgCancelMigrationResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgCancelMigrationResponse",
+    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 = createBaseMsgCancelMigrationResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCancelMigrationResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCancelMigrationResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCancelMigrationResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCancelMigrationResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCancelMigrationResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgCancelMigrationResponse",
+            value: MsgCancelMigrationResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgSetRecoveryCommitment() {
+    return {
+        member: "",
+        commitment: new Uint8Array(),
+        replaces: new Uint8Array()
+    };
+}
+/**
+ * MsgSetRecoveryCommitment adds (or replaces) one of the member's recovery
+ * commitments, at most MaxRecoveryCommitments (4). It takes effect after
+ * recovery_change_delay, so whoever holds the key cannot swap in their own
+ * commitment or use the recovery path as a faster key path. The only
+ * immediate commitment is the one carried by MsgAcceptInvitation.
+ * @name MsgSetRecoveryCommitment
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgSetRecoveryCommitment
+ */
+export const MsgSetRecoveryCommitment = {
+    typeUrl: "/sparkdream.rep.v1.MsgSetRecoveryCommitment",
+    aminoType: "sparkdream/x/rep/MsgSetRecoveryCommitment",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.member !== "") {
+            writer.uint32(10).string(message.member);
+        }
+        if (message.commitment.length !== 0) {
+            writer.uint32(18).bytes(message.commitment);
+        }
+        if (message.replaces.length !== 0) {
+            writer.uint32(26).bytes(message.replaces);
+        }
+        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 = createBaseMsgSetRecoveryCommitment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.member = reader.string();
+                    break;
+                case 2:
+                    message.commitment = reader.bytes();
+                    break;
+                case 3:
+                    message.replaces = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSetRecoveryCommitment();
+        message.member = object.member ?? "";
+        message.commitment = object.commitment ?? new Uint8Array();
+        message.replaces = object.replaces ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgSetRecoveryCommitment();
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.commitment !== undefined && object.commitment !== null) {
+            message.commitment = bytesFromBase64(object.commitment);
+        }
+        if (object.replaces !== undefined && object.replaces !== null) {
+            message.replaces = bytesFromBase64(object.replaces);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.commitment = message.commitment ? base64FromBytes(message.commitment) : undefined;
+        obj.replaces = message.replaces ? base64FromBytes(message.replaces) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgSetRecoveryCommitment.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgSetRecoveryCommitment",
+            value: MsgSetRecoveryCommitment.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgSetRecoveryCommitment.decode(message.value);
+    },
+    toProto(message) {
+        return MsgSetRecoveryCommitment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgSetRecoveryCommitment",
+            value: MsgSetRecoveryCommitment.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgSetRecoveryCommitmentResponse() {
+    return {};
+}
+/**
+ * MsgSetRecoveryCommitmentResponse defines the MsgSetRecoveryCommitmentResponse message.
+ * @name MsgSetRecoveryCommitmentResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgSetRecoveryCommitmentResponse
+ */
+export const MsgSetRecoveryCommitmentResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgSetRecoveryCommitmentResponse",
+    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 = createBaseMsgSetRecoveryCommitmentResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgSetRecoveryCommitmentResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgSetRecoveryCommitmentResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgSetRecoveryCommitmentResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgSetRecoveryCommitmentResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgSetRecoveryCommitmentResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgSetRecoveryCommitmentResponse",
+            value: MsgSetRecoveryCommitmentResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRemoveRecoveryCommitment() {
+    return {
+        member: "",
+        commitment: new Uint8Array()
+    };
+}
+/**
+ * MsgRemoveRecoveryCommitment schedules the removal of a commitment after
+ * recovery_change_delay; it stays usable for a reveal until then.
+ * @name MsgRemoveRecoveryCommitment
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRemoveRecoveryCommitment
+ */
+export const MsgRemoveRecoveryCommitment = {
+    typeUrl: "/sparkdream.rep.v1.MsgRemoveRecoveryCommitment",
+    aminoType: "sparkdream/x/rep/MsgRemoveRecoveryCommitment",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.member !== "") {
+            writer.uint32(10).string(message.member);
+        }
+        if (message.commitment.length !== 0) {
+            writer.uint32(18).bytes(message.commitment);
+        }
+        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 = createBaseMsgRemoveRecoveryCommitment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.member = reader.string();
+                    break;
+                case 2:
+                    message.commitment = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRemoveRecoveryCommitment();
+        message.member = object.member ?? "";
+        message.commitment = object.commitment ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRemoveRecoveryCommitment();
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.commitment !== undefined && object.commitment !== null) {
+            message.commitment = bytesFromBase64(object.commitment);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.commitment = message.commitment ? base64FromBytes(message.commitment) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRemoveRecoveryCommitment.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgRemoveRecoveryCommitment",
+            value: MsgRemoveRecoveryCommitment.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRemoveRecoveryCommitment.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRemoveRecoveryCommitment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRemoveRecoveryCommitment",
+            value: MsgRemoveRecoveryCommitment.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRemoveRecoveryCommitmentResponse() {
+    return {};
+}
+/**
+ * MsgRemoveRecoveryCommitmentResponse defines the MsgRemoveRecoveryCommitmentResponse message.
+ * @name MsgRemoveRecoveryCommitmentResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRemoveRecoveryCommitmentResponse
+ */
+export const MsgRemoveRecoveryCommitmentResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgRemoveRecoveryCommitmentResponse",
+    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 = createBaseMsgRemoveRecoveryCommitmentResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRemoveRecoveryCommitmentResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRemoveRecoveryCommitmentResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRemoveRecoveryCommitmentResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRemoveRecoveryCommitmentResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRemoveRecoveryCommitmentResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRemoveRecoveryCommitmentResponse",
+            value: MsgRemoveRecoveryCommitmentResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCommitRecovery() {
+    return {
+        submitter: "",
+        sealed: new Uint8Array()
+    };
+}
+/**
+ * MsgCommitRecovery stores a sealed commit, the front-running guard of a
+ * reveal, against recovery_commit_deposit (refunded when a reveal consumes
+ * the seal, burned when it expires after recovery_commit_ttl). Any account
+ * may submit it; it reveals nothing about the member, the preimage or the
+ * target.
+ * @name MsgCommitRecovery
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgCommitRecovery
+ */
+export const MsgCommitRecovery = {
+    typeUrl: "/sparkdream.rep.v1.MsgCommitRecovery",
+    aminoType: "sparkdream/x/rep/MsgCommitRecovery",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.submitter !== "") {
+            writer.uint32(10).string(message.submitter);
+        }
+        if (message.sealed.length !== 0) {
+            writer.uint32(18).bytes(message.sealed);
+        }
+        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 = createBaseMsgCommitRecovery();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.submitter = reader.string();
+                    break;
+                case 2:
+                    message.sealed = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCommitRecovery();
+        message.submitter = object.submitter ?? "";
+        message.sealed = object.sealed ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCommitRecovery();
+        if (object.submitter !== undefined && object.submitter !== null) {
+            message.submitter = object.submitter;
+        }
+        if (object.sealed !== undefined && object.sealed !== null) {
+            message.sealed = bytesFromBase64(object.sealed);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.submitter = message.submitter === "" ? undefined : message.submitter;
+        obj.sealed = message.sealed ? base64FromBytes(message.sealed) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCommitRecovery.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgCommitRecovery",
+            value: MsgCommitRecovery.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgCommitRecovery.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCommitRecovery.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgCommitRecovery",
+            value: MsgCommitRecovery.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCommitRecoveryResponse() {
+    return {};
+}
+/**
+ * MsgCommitRecoveryResponse defines the MsgCommitRecoveryResponse message.
+ * @name MsgCommitRecoveryResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgCommitRecoveryResponse
+ */
+export const MsgCommitRecoveryResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgCommitRecoveryResponse",
+    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 = createBaseMsgCommitRecoveryResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCommitRecoveryResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCommitRecoveryResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCommitRecoveryResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCommitRecoveryResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCommitRecoveryResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgCommitRecoveryResponse",
+            value: MsgCommitRecoveryResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRevealRecovery() {
+    return {
+        revealer: "",
+        member: "",
+        newAddress: "",
+        preimage: new Uint8Array()
+    };
+}
+/**
+ * MsgRevealRecovery opens a RECOVERY migration of member to new_address by
+ * revealing the preimage of one of member's active commitments. The sealed
+ * commit binding (preimage, member, new_address) must exist and have aged
+ * recovery_reveal_min_blocks. Signed by any account: the seal already binds
+ * the target, and new_address confirms control afterwards with
+ * MsgAcceptMigration. The matched commitment is consumed, pending commitment
+ * changes are voided and any pending KEY or COUNCIL migration is cancelled.
+ * @name MsgRevealRecovery
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevealRecovery
+ */
+export const MsgRevealRecovery = {
+    typeUrl: "/sparkdream.rep.v1.MsgRevealRecovery",
+    aminoType: "sparkdream/x/rep/MsgRevealRecovery",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.revealer !== "") {
+            writer.uint32(10).string(message.revealer);
+        }
+        if (message.member !== "") {
+            writer.uint32(18).string(message.member);
+        }
+        if (message.newAddress !== "") {
+            writer.uint32(26).string(message.newAddress);
+        }
+        if (message.preimage.length !== 0) {
+            writer.uint32(34).bytes(message.preimage);
+        }
+        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 = createBaseMsgRevealRecovery();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.revealer = reader.string();
+                    break;
+                case 2:
+                    message.member = reader.string();
+                    break;
+                case 3:
+                    message.newAddress = reader.string();
+                    break;
+                case 4:
+                    message.preimage = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRevealRecovery();
+        message.revealer = object.revealer ?? "";
+        message.member = object.member ?? "";
+        message.newAddress = object.newAddress ?? "";
+        message.preimage = object.preimage ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRevealRecovery();
+        if (object.revealer !== undefined && object.revealer !== null) {
+            message.revealer = object.revealer;
+        }
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.new_address !== undefined && object.new_address !== null) {
+            message.newAddress = object.new_address;
+        }
+        if (object.preimage !== undefined && object.preimage !== null) {
+            message.preimage = bytesFromBase64(object.preimage);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.revealer = message.revealer === "" ? undefined : message.revealer;
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.new_address = message.newAddress === "" ? undefined : message.newAddress;
+        obj.preimage = message.preimage ? base64FromBytes(message.preimage) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevealRecovery.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgRevealRecovery",
+            value: MsgRevealRecovery.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRevealRecovery.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevealRecovery.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRevealRecovery",
+            value: MsgRevealRecovery.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRevealRecoveryResponse() {
+    return {
+        migrationId: BigInt(0)
+    };
+}
+/**
+ * MsgRevealRecoveryResponse defines the MsgRevealRecoveryResponse message.
+ * @name MsgRevealRecoveryResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevealRecoveryResponse
+ */
+export const MsgRevealRecoveryResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgRevealRecoveryResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.migrationId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.migrationId);
+        }
+        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 = createBaseMsgRevealRecoveryResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.migrationId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRevealRecoveryResponse();
+        message.migrationId = object.migrationId !== undefined && object.migrationId !== null ? BigInt(object.migrationId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRevealRecoveryResponse();
+        if (object.migration_id !== undefined && object.migration_id !== null) {
+            message.migrationId = BigInt(object.migration_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.migration_id = message.migrationId !== BigInt(0) ? message.migrationId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevealRecoveryResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRevealRecoveryResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevealRecoveryResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgRevealRecoveryResponse",
+            value: MsgRevealRecoveryResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgObjectMigration() {
+    return {
+        member: "",
+        migrationId: BigInt(0),
+        reason: ""
+    };
+}
+/**
+ * MsgObjectMigration lets the old address contest a COUNCIL migration
+ * during its delay. It does not cancel the migration: the objector posts
+ * migration_objection_bond and an x/rep jury decides. The bond is paid to
+ * the new address if the migration is upheld and refunded otherwise, never
+ * burned.
+ * @name MsgObjectMigration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgObjectMigration
+ */
+export const MsgObjectMigration = {
+    typeUrl: "/sparkdream.rep.v1.MsgObjectMigration",
+    aminoType: "sparkdream/x/rep/MsgObjectMigration",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.member !== "") {
+            writer.uint32(10).string(message.member);
+        }
+        if (message.migrationId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.migrationId);
+        }
+        if (message.reason !== "") {
+            writer.uint32(26).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 = createBaseMsgObjectMigration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.member = reader.string();
+                    break;
+                case 2:
+                    message.migrationId = reader.uint64();
+                    break;
+                case 3:
+                    message.reason = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgObjectMigration();
+        message.member = object.member ?? "";
+        message.migrationId = object.migrationId !== undefined && object.migrationId !== null ? BigInt(object.migrationId.toString()) : BigInt(0);
+        message.reason = object.reason ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgObjectMigration();
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.migration_id !== undefined && object.migration_id !== null) {
+            message.migrationId = BigInt(object.migration_id);
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.migration_id = message.migrationId !== BigInt(0) ? message.migrationId?.toString() : undefined;
+        obj.reason = message.reason === "" ? undefined : message.reason;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgObjectMigration.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgObjectMigration",
+            value: MsgObjectMigration.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgObjectMigration.decode(message.value);
+    },
+    toProto(message) {
+        return MsgObjectMigration.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgObjectMigration",
+            value: MsgObjectMigration.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgObjectMigrationResponse() {
+    return {};
+}
+/**
+ * MsgObjectMigrationResponse defines the MsgObjectMigrationResponse message.
+ * @name MsgObjectMigrationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgObjectMigrationResponse
+ */
+export const MsgObjectMigrationResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgObjectMigrationResponse",
+    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 = createBaseMsgObjectMigrationResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgObjectMigrationResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgObjectMigrationResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgObjectMigrationResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgObjectMigrationResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgObjectMigrationResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgObjectMigrationResponse",
+            value: MsgObjectMigrationResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgSweepTombstone() {
+    return {
+        signer: "",
+        tombstone: ""
+    };
+}
+/**
+ * MsgSweepTombstone moves a tombstone's spendable SPARK to its canonical
+ * address, which signs. Unbonding completes to the old address outside the
+ * bank send restriction; on the recovery and council paths the old key may
+ * not MsgSend it, so this is how the member collects it.
+ * @name MsgSweepTombstone
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgSweepTombstone
+ */
+export const MsgSweepTombstone = {
+    typeUrl: "/sparkdream.rep.v1.MsgSweepTombstone",
+    aminoType: "sparkdream/x/rep/MsgSweepTombstone",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.tombstone !== "") {
+            writer.uint32(18).string(message.tombstone);
+        }
+        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 = createBaseMsgSweepTombstone();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.tombstone = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSweepTombstone();
+        message.signer = object.signer ?? "";
+        message.tombstone = object.tombstone ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgSweepTombstone();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.tombstone !== undefined && object.tombstone !== null) {
+            message.tombstone = object.tombstone;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.tombstone = message.tombstone === "" ? undefined : message.tombstone;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgSweepTombstone.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgSweepTombstone",
+            value: MsgSweepTombstone.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgSweepTombstone.decode(message.value);
+    },
+    toProto(message) {
+        return MsgSweepTombstone.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgSweepTombstone",
+            value: MsgSweepTombstone.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgSweepTombstoneResponse() {
+    return {};
+}
+/**
+ * MsgSweepTombstoneResponse defines the MsgSweepTombstoneResponse message.
+ * @name MsgSweepTombstoneResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgSweepTombstoneResponse
+ */
+export const MsgSweepTombstoneResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgSweepTombstoneResponse",
+    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 = createBaseMsgSweepTombstoneResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgSweepTombstoneResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgSweepTombstoneResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgSweepTombstoneResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgSweepTombstoneResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgSweepTombstoneResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgSweepTombstoneResponse",
+            value: MsgSweepTombstoneResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgForceMigration() {
+    return {
+        authority: "",
+        member: "",
+        newAddress: "",
+        evidenceUri: ""
+    };
+}
+/**
+ * MsgForceMigration opens a COUNCIL migration of member to new_address on
+ * off-chain evidence (a lost key with no recovery commitment). The authority
+ * is the Commons HR (governance) committee policy or x/gov. new_address must
+ * still accept; the old address may object to a jury during
+ * council_migration_delay. An open member report does not block it.
+ * @name MsgForceMigration
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgForceMigration
+ */
+export const MsgForceMigration = {
+    typeUrl: "/sparkdream.rep.v1.MsgForceMigration",
+    aminoType: "sparkdream/x/rep/MsgForceMigration",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.member !== "") {
+            writer.uint32(18).string(message.member);
+        }
+        if (message.newAddress !== "") {
+            writer.uint32(26).string(message.newAddress);
+        }
+        if (message.evidenceUri !== "") {
+            writer.uint32(34).string(message.evidenceUri);
+        }
+        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 = createBaseMsgForceMigration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.member = reader.string();
+                    break;
+                case 3:
+                    message.newAddress = reader.string();
+                    break;
+                case 4:
+                    message.evidenceUri = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgForceMigration();
+        message.authority = object.authority ?? "";
+        message.member = object.member ?? "";
+        message.newAddress = object.newAddress ?? "";
+        message.evidenceUri = object.evidenceUri ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgForceMigration();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.new_address !== undefined && object.new_address !== null) {
+            message.newAddress = object.new_address;
+        }
+        if (object.evidence_uri !== undefined && object.evidence_uri !== null) {
+            message.evidenceUri = object.evidence_uri;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.new_address = message.newAddress === "" ? undefined : message.newAddress;
+        obj.evidence_uri = message.evidenceUri === "" ? undefined : message.evidenceUri;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgForceMigration.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgForceMigration",
+            value: MsgForceMigration.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgForceMigration.decode(message.value);
+    },
+    toProto(message) {
+        return MsgForceMigration.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgForceMigration",
+            value: MsgForceMigration.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgForceMigrationResponse() {
+    return {
+        migrationId: BigInt(0)
+    };
+}
+/**
+ * MsgForceMigrationResponse defines the MsgForceMigrationResponse message.
+ * @name MsgForceMigrationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgForceMigrationResponse
+ */
+export const MsgForceMigrationResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgForceMigrationResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.migrationId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.migrationId);
+        }
+        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 = createBaseMsgForceMigrationResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.migrationId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgForceMigrationResponse();
+        message.migrationId = object.migrationId !== undefined && object.migrationId !== null ? BigInt(object.migrationId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgForceMigrationResponse();
+        if (object.migration_id !== undefined && object.migration_id !== null) {
+            message.migrationId = BigInt(object.migration_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.migration_id = message.migrationId !== BigInt(0) ? message.migrationId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgForceMigrationResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgForceMigrationResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgForceMigrationResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgForceMigrationResponse",
+            value: MsgForceMigrationResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgClearZkPublicKey() {
+    return {
+        member: ""
+    };
+}
+/**
+ * MsgClearZkPublicKey zeroes the member's zk_public_key and any
+ * pending_zk_public_key at once and registers nothing in their place. It is
+ * the remedy for a leaked shield secret: unlike a key change it has no
+ * cooldown and no per-season limit, because zeroing can only take capability
+ * away. It sets zk_key_cleared, so the next MsgRegisterZkPublicKey is never
+ * immediate (it waits zk_key_activation_delay) and still honours the
+ * once-per-season change cap; clear-then-register is not a free key swap.
+ * Never session-delegable, never shield-compatible (rep identity list).
+ * @name MsgClearZkPublicKey
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgClearZkPublicKey
+ */
+export const MsgClearZkPublicKey = {
+    typeUrl: "/sparkdream.rep.v1.MsgClearZkPublicKey",
+    aminoType: "sparkdream/x/rep/MsgClearZkPublicKey",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.member !== "") {
+            writer.uint32(10).string(message.member);
+        }
+        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 = createBaseMsgClearZkPublicKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.member = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgClearZkPublicKey();
+        message.member = object.member ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgClearZkPublicKey();
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.member = message.member === "" ? undefined : message.member;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClearZkPublicKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/rep/MsgClearZkPublicKey",
+            value: MsgClearZkPublicKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgClearZkPublicKey.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClearZkPublicKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgClearZkPublicKey",
+            value: MsgClearZkPublicKey.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgClearZkPublicKeyResponse() {
+    return {};
+}
+/**
+ * MsgClearZkPublicKeyResponse defines the MsgClearZkPublicKeyResponse message.
+ * @name MsgClearZkPublicKeyResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgClearZkPublicKeyResponse
+ */
+export const MsgClearZkPublicKeyResponse = {
+    typeUrl: "/sparkdream.rep.v1.MsgClearZkPublicKeyResponse",
+    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 = createBaseMsgClearZkPublicKeyResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgClearZkPublicKeyResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgClearZkPublicKeyResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClearZkPublicKeyResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgClearZkPublicKeyResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClearZkPublicKeyResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.MsgClearZkPublicKeyResponse",
+            value: MsgClearZkPublicKeyResponse.encode(message).finish()
+        };
+    }
+};