@ermis-network/ermis-chat-react 1.0.9 → 2.0.1

package/src/hooks/useMessageActions.ts

@@ -1,8 +1,9 @@
 import { useMemo } from 'react';
 import { useChatClient } from './useChatClient';
 import { useChannelCapabilities } from './useChannelCapabilities';
+import { usePreviewState } from './usePreviewState';
 import type { FormatMessageResponse } from '@ermis-network/ermis-chat-sdk';
-import { isSignalMessage, isSystemMessage } from '../messageTypeUtils';
+import { isSignalMessage, isSystemMessage, isStickerMessage } from '../messageTypeUtils';
 
 export type MessageActionList = {
   canEdit: boolean;
@@ -20,11 +21,13 @@ export type MessageActionList = {
   hasCapPin: boolean;
   hasCapReply: boolean;
   hasCapQuote: boolean;
+  hasCapReact: boolean;
 };
 
 export const useMessageActions = (message: FormatMessageResponse, isOwnMessage: boolean): MessageActionList => {
   const { activeChannel, client } = useChatClient();
   const { isGroupChannel: isTeam, isOwner, hasCapability } = useChannelCapabilities();
+  const { isPreviewMode } = usePreviewState(activeChannel, client?.userID);
 
   // Only depend on the specific message fields we actually read
   const messageType = message.type;
@@ -48,14 +51,18 @@ export const useMessageActions = (message: FormatMessageResponse, isOwnMessage:
         hasCapPin: false,
         hasCapReply: false,
         hasCapQuote: false,
+        hasCapReact: false,
       };
     }
 
     const isSystem = isSystemMessage(message);
     const isSignal = isSignalMessage(message);
+    const isSticker = isStickerMessage(message);
     const isPinned = isPinnedFlag;
 
-    const canEdit = !isSystem && !isSignal && isOwnMessage;
+    const isDeleted = message.display_type === 'deleted';
+
+    const canEdit = !isPreviewMode && !isSystem && !isSignal && !isSticker && isOwnMessage && !isDeleted;
 
     // Delete for everyone:
     // + Team channel: only the owner can perform this action natively.
@@ -63,13 +70,13 @@ export const useMessageActions = (message: FormatMessageResponse, isOwnMessage:
     const canDeleteForEveryoneTeam = isTeam && isOwner;
     const canDeleteForEveryoneMessaging = !isTeam && isOwnMessage;
 
-    const canDelete = !isSystem && (canDeleteForEveryoneTeam || canDeleteForEveryoneMessaging);
-    const canDeleteForMe = !isSystem;
-    const canReply = !isSystem && !isSignal;
-    const canQuote = !isSystem && !isSignal;
-    const canForward = !isSystem && !isSignal;
-    const canPin = !isSystem && !isSignal;
-    const canCopy = !isSystem && !isSignal && Boolean(message.text?.trim());
+    const canDelete = !isPreviewMode && !isSystem && (canDeleteForEveryoneTeam || canDeleteForEveryoneMessaging) && !isDeleted;
+    const canDeleteForMe = !isPreviewMode && !isSystem && !isDeleted;
+    const canReply = !isPreviewMode && !isSystem && !isSignal && !isDeleted;
+    const canQuote = !isPreviewMode && !isSystem && !isSignal && !isDeleted;
+    const canForward = !isPreviewMode && !isSystem && !isSignal && !isDeleted;
+    const canPin = !isPreviewMode && !isSystem && !isSignal && !isDeleted;
+    const canCopy = !isSystem && !isSignal && Boolean(message.text?.trim()) && !isDeleted; // Allow copy even in preview mode
 
     const hasCapEdit = hasCapability('update-own-message');
     const hasCapDelete = !isTeam || isOwner || (isOwnMessage && hasCapability('delete-own-message'));
@@ -79,6 +86,7 @@ export const useMessageActions = (message: FormatMessageResponse, isOwnMessage:
     const hasCapReply = hasCapability('send-reply');
     const hasCapQuote = hasCapability('quote-message');
     const hasCapPin = hasCapability('pin-message');
+    const hasCapReact = hasCapability('send-reaction');
 
     return {
       canEdit,
@@ -96,6 +104,7 @@ export const useMessageActions = (message: FormatMessageResponse, isOwnMessage:
       hasCapPin,
       hasCapReply,
       hasCapQuote,
+      hasCapReact,
     };
-  }, [activeChannel, isTeam, isOwner, hasCapability, messageType, message.text, isPinnedFlag, isOwnMessage]); // Use capabilities from hook
+  }, [activeChannel, isTeam, isOwner, hasCapability, messageType, message.text, isPinnedFlag, isOwnMessage, isPreviewMode]); // Use capabilities from hook
 };

package/src/hooks/useMessageSend.ts

@@ -58,7 +58,12 @@ export function useMessageSend({
 
     const payload = buildPayload();
     const text = payload.text.trim();
-    const uploadedFiles = files.filter((f) => f.status === 'done');
+    const isE2eeChannelForFiles =
+      !!activeChannel &&
+      (typeof (activeChannel as any)._isEffectiveE2ee === 'function'
+        ? (activeChannel as any)._isEffectiveE2ee()
+        : activeChannel.data?.mls_enabled === true);
+    const uploadedFiles = files.filter((f) => f.status === 'done' || (isE2eeChannelForFiles && f.status === 'pending'));
 
     if (!text && uploadedFiles.length === 0) return;
 
@@ -73,15 +78,49 @@ export function useMessageSend({
 
     try {
       setSending(true);
+      const isE2eeChannel =
+        typeof (activeChannel as any)._isEffectiveE2ee === 'function'
+          ? (activeChannel as any)._isEffectiveE2ee()
+          : activeChannel.data?.mls_enabled === true;
 
       // Build attachment payloads from already-uploaded files (only applied on new messages)
-      const attachments = uploadedFiles.map((f) => {
-        if (f.originalAttachment) {
-          return f.originalAttachment;
+      let attachments: unknown[] = [];
+      let e2eeAttachmentIds: string[] | undefined;
+      if (isE2eeChannel && !editingMessage && uploadedFiles.length > 0) {
+        const encryptionMgr = (activeChannel as any).getClient?.().encryptionManager;
+        if (!encryptionMgr?.initialized) throw new Error('E2EE attachments require an initialized encryption manager');
+        const filesToUpload = uploadedFiles.map((f) => f.normalizedFile || f.file!).filter(Boolean);
+        const message: Record<string, any> = { text };
+        if (isTeamChannel) {
+          message.mentioned_all = payload.mentioned_all;
+          message.mentioned_users = payload.mentioned_users;
         }
-        const fileObj = f.normalizedFile || f.file!;
-        return buildAttachmentPayload(fileObj, f.uploadedUrl!, f.thumbUrl);
-      });
+        if (quotedMessage?.id) {
+          message.quoted_message_id = quotedMessage.id;
+        }
+        await (activeChannel as any).enqueueE2eeAttachmentMessage(message, filesToUpload);
+        syncMessages();
+
+        files.forEach((f) => {
+          if (f.previewUrl) URL.revokeObjectURL(f.previewUrl);
+        });
+        const errorFiles = files.filter((f) => f.status === 'error');
+        setFiles(errorFiles);
+        setHasContent(errorFiles.length > 0);
+        reset();
+        clearQuotedMessage?.();
+        onSend?.(payload.text);
+        activeChannel?.stopTyping();
+        return;
+      } else {
+        attachments = uploadedFiles.map((f) => {
+          if (f.originalAttachment) {
+            return f.originalAttachment;
+          }
+          const fileObj = f.normalizedFile || f.file!;
+          return buildAttachmentPayload(fileObj, f.uploadedUrl!, f.thumbUrl);
+        });
+      }
 
       // Build message
       const message: Record<string, any> = { text };
@@ -90,6 +129,9 @@ export function useMessageSend({
       if (!editingMessage && attachments.length > 0) {
         message.attachments = attachments;
       }
+      if (!editingMessage && e2eeAttachmentIds && e2eeAttachmentIds.length > 0) {
+        message.e2ee_attachment_ids = e2eeAttachmentIds;
+      }
 
       if (isTeamChannel) {
         message.mentioned_all = payload.mentioned_all;
@@ -130,11 +172,17 @@ export function useMessageSend({
       // --- 2. DELEGATE TO WEBSOCKET ---
       // The API call runs in background. We do not block the UI for resolution.
       // Message lists will automatically update when the backend blasts the `message.new` WS event.
-      sendPromise.catch((err: Error) => {
-        console.error('Failed to send message over API:', err);
-        // Sync React to render the SDK's internal 'status: failed' UI state
-        syncMessages();
-      });
+      sendPromise
+        .then(() => {
+          // E2EE own-device WS events may arrive before the SDK replaces the
+          // optimistic message with the confirmed local plaintext snapshot.
+          syncMessages();
+        })
+        .catch((err: Error) => {
+          console.error('Failed to send message over API:', err);
+          // Sync React to render the SDK's internal 'status: failed' UI state
+          syncMessages();
+        });
     } catch (err) {
       console.error('Failed to process message send:', err);
     } finally {
@@ -158,6 +206,10 @@ export function useMessageSend({
     editableRef,
     setFiles,
     setHasContent,
+    quotedMessage,
+    clearQuotedMessage,
+    editingMessage,
+    clearEditingMessage,
   ]);
 
   return { sending, handleSend };

package/src/hooks/usePendingE2eeSends.ts

@@ -0,0 +1,29 @@
+import { useCallback, useEffect, useState } from 'react';
+import type { PendingE2eeSendRecord } from '@ermis-network/ermis-chat-sdk';
+import { useChatClient } from './useChatClient';
+
+export function usePendingE2eeSends(statuses?: string[]) {
+  const { client } = useChatClient();
+  const [records, setRecords] = useState<PendingE2eeSendRecord[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  const refresh = useCallback(async () => {
+    const storage = client.encryptionManager?.storage;
+    if (!storage?.listPendingE2eeSends) {
+      setRecords([]);
+      return;
+    }
+    setLoading(true);
+    try {
+      setRecords(await storage.listPendingE2eeSends(statuses));
+    } finally {
+      setLoading(false);
+    }
+  }, [client.encryptionManager, JSON.stringify(statuses || [])]);
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  return { records, loading, refresh };
+}

package/src/hooks/usePendingState.ts

@@ -10,6 +10,7 @@ export function usePendingState(channel: Channel | null | undefined, currentUser
     const membership = channel?.state?.membership || channel?.state?.members?.[currentUserId || ''];
     return isPendingMember(membership?.channel_role as string);
   });
+  const [inviteUpdateCount, setInviteUpdateCount] = useState(0);
 
   useEffect(() => {
     if (!channel || !currentUserId) {
@@ -18,6 +19,10 @@ export function usePendingState(channel: Channel | null | undefined, currentUser
     }
 
     const checkPending = () => {
+      // Topics are accessible by default if the user is in the parent channel.
+      // We ignore the individual pending invite state for topics to avoid redundant overlays.
+      if (channel.type === 'topic') return false;
+
       const membership = channel.state?.membership || channel.state?.members?.[currentUserId];
       return isPendingMember(membership?.channel_role as string);
     };
@@ -40,29 +45,41 @@ export function usePendingState(channel: Channel | null | undefined, currentUser
       const eventMember = event.member as Record<string, unknown>;
       const eventUser = event.user as Record<string, unknown>;
       const eventUserId = eventMember?.user_id || (eventMember?.user as Record<string, unknown>)?.id || eventUser?.id;
-      if (eventUserId !== currentUserId) return; // Only react to own invite events
 
       const eventCid =
         event.cid ||
         (event.channel as Record<string, unknown>)?.cid ||
         (event.channel_id ? `${event.channel_type}:${event.channel_id}` : undefined);
-      if (eventCid === channel.cid) {
+
+      if (eventCid !== channel.cid) return; // Only react to events on this channel
+
+      // If this event is for the current user, update their membership state
+      if (eventUserId === currentUserId) {
         defensiveUpdateState(event);
-        setIsPending(checkPending());
       }
+
+      // Re-check pending state regardless of which user triggered the event.
+      // This handles both cases:
+      // - Current user accepts/rejects their own invite
+      // - Another user accepts an invite (hide pending-invitee box on inviter's side)
+      setIsPending(checkPending());
+      setInviteUpdateCount(c => c + 1);
     };
 
     const client = channel.getClient();
     const sub1 = client.on('notification.invite_accepted', handleInviteAction);
     const sub2 = client.on('notification.invite_rejected', handleInviteAction);
     const sub3 = client.on('notification.invite_messaging_skipped', handleInviteAction);
+    // Public channel join sends 'member.joined' instead of 'notification.invite_accepted'
+    const sub4 = client.on('member.joined', handleInviteAction);
 
     return () => {
       sub1.unsubscribe();
       sub2.unsubscribe();
       sub3.unsubscribe();
+      sub4.unsubscribe();
     };
   }, [channel, currentUserId]);
 
-  return { isPending };
+  return { isPending, inviteUpdateCount };
 }

package/src/hooks/usePreviewState.ts

@@ -0,0 +1,69 @@
+import { useState, useEffect } from 'react';
+import type { Channel } from '@ermis-network/ermis-chat-sdk';
+import { isPublicGroupChannel } from '../channelTypeUtils';
+
+/**
+ * Hook that tracks whether the current user is previewing a public channel
+ * without being a member.
+ */
+export function usePreviewState(channel: Channel | null | undefined, currentUserId?: string) {
+  const [isPreviewMode, setIsPreviewMode] = useState<boolean>(() => {
+    if (!channel || !currentUserId || !isPublicGroupChannel(channel)) return false;
+    const membership = channel?.state?.membership || channel?.state?.members?.[currentUserId];
+    const isMembershipEmpty = !membership || Object.keys(membership).length === 0;
+    return isMembershipEmpty;
+  });
+
+  useEffect(() => {
+    if (!channel || !currentUserId || !isPublicGroupChannel(channel)) {
+      setIsPreviewMode(false);
+      return;
+    }
+
+    const checkPreviewMode = () => {
+      const membership = channel.state?.membership || channel.state?.members?.[currentUserId];
+      const isMembershipEmpty = !membership || Object.keys(membership).length === 0;
+      return isMembershipEmpty;
+    };
+
+    // Sync initial state
+    setIsPreviewMode(checkPreviewMode());
+
+    const defensiveUpdateState = (event: Record<string, unknown>) => {
+      if (event.member && channel.state && channel.state.membership !== undefined) {
+        channel.state.membership = {
+          ...channel.state.membership,
+          ...(event.member as Record<string, unknown>),
+        } as unknown as Record<string, unknown>;
+      }
+    };
+
+    const handleMembershipChange = (event: Record<string, unknown>) => {
+      const eventMember = event.member as Record<string, unknown>;
+      const eventUser = event.user as Record<string, unknown>;
+      const eventUserId = eventMember?.user_id || (eventMember?.user as Record<string, unknown>)?.id || eventUser?.id;
+
+      // Only react if the event concerns the current user
+      if (eventUserId !== currentUserId) return;
+
+      const eventCid =
+        event.cid ||
+        (event.channel as Record<string, unknown>)?.cid ||
+        (event.channel_id ? `${event.channel_type}:${event.channel_id}` : undefined);
+
+      if (eventCid === channel.cid) {
+        defensiveUpdateState(event);
+        setIsPreviewMode(checkPreviewMode());
+      }
+    };
+
+    const client = channel.getClient();
+    const sub1 = client.on('member.joined', handleMembershipChange);
+
+    return () => {
+      sub1.unsubscribe();
+    };
+  }, [channel, currentUserId]);
+
+  return { isPreviewMode };
+}

package/src/hooks/useRecoveryPin.ts

@@ -0,0 +1,287 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import type {
+  EncryptedChannelRepairMode,
+  EncryptedChannelRepairResult,
+  RepairMode,
+  RepairResult,
+  RestoreProgressRecord,
+} from '@ermis-network/ermis-chat-sdk';
+
+import { useChatClient } from './useChatClient';
+
+export type RecoveryPinStatus = 'idle' | 'working' | 'ready' | 'locked' | 'error';
+
+export type RecoveryStatusInfo = {
+  hasVault: boolean;
+  unlocked: boolean;
+  hasIncompleteRestore: boolean;
+  incompleteChannels: string[];
+  channelsWithPermanentGaps: string[];
+  restoreProgressWithIssues: RestoreProgressRecord[];
+  e2eeBootstrapRunning?: boolean;
+  e2eeBootstrapCompleted?: number;
+  e2eeBootstrapTotal?: number;
+};
+
+export type RecoveryRestoredMessage = {
+  epoch: number;
+  messageId?: string;
+  plaintext?: unknown;
+  source?: 'archive';
+  createdAt?: string;
+  gap?: boolean;
+  reason?: string;
+};
+
+export type UseRecoveryPinReturn = {
+  status: RecoveryPinStatus;
+  error: Error | null;
+  hasRecoveryKey: boolean;
+  recoveryStatus: RecoveryStatusInfo | null;
+  setupRecoveryPin: (pin: string) => Promise<void>;
+  unlockRecoveryVault: (pin: string) => Promise<void>;
+  changeRecoveryPin: (oldPin: string, newPin: string) => Promise<void>;
+  changeUnlockedRecoveryPin: (newPin: string) => Promise<void>;
+  repairRecoveryChannel: (
+    channelType: string,
+    channelId: string,
+    options?: { mode?: RepairMode },
+  ) => Promise<RepairResult>;
+  repairEncryptedChannel: (
+    channelType: string,
+    channelId: string,
+    options?: { mode?: EncryptedChannelRepairMode },
+  ) => Promise<EncryptedChannelRepairResult>;
+  enqueueRestore: (
+    channelType: string,
+    channelId: string,
+    priority?: 'active' | 'background',
+    options?: { fromEpoch?: number; toEpoch?: number },
+  ) => void;
+  loadRestoreProgress: (channelType: string, channelId: string) => Promise<RestoreProgressRecord | null>;
+  restoreHistoricalMessages: (
+    channelType: string,
+    channelId: string,
+    options?: { fromEpoch?: number; toEpoch?: number },
+  ) => Promise<RecoveryRestoredMessage[]>;
+  refresh: () => void;
+};
+
+const requireEncryptionManager = (client: unknown): any => {
+  const manager = (client as any)?.encryptionManager;
+  if (!manager) {
+    throw new Error('Encryption manager is not initialized.');
+  }
+  return manager;
+};
+
+export const useRecoveryPin = (): UseRecoveryPinReturn => {
+  const { client } = useChatClient();
+  const [status, setStatus] = useState<RecoveryPinStatus>('idle');
+  const [error, setError] = useState<Error | null>(null);
+  const [recoveryStatus, setRecoveryStatus] = useState<RecoveryStatusInfo | null>(null);
+  const [hasRecoveryKey, setHasRecoveryKey] = useState(() => {
+    try {
+      return !!requireEncryptionManager(client).hasRecoveryKey?.();
+    } catch {
+      return false;
+    }
+  });
+
+  const refresh = useCallback(() => {
+    void (async () => {
+      try {
+        const manager = requireEncryptionManager(client);
+        const hasKey = !!manager.hasRecoveryKey?.();
+        const nextStatus = manager.getRecoveryStatus ? await manager.getRecoveryStatus() : null;
+        setHasRecoveryKey(hasKey);
+        setRecoveryStatus(nextStatus);
+        setStatus(nextStatus?.hasVault === false ? 'idle' : nextStatus?.unlocked ? 'ready' : 'locked');
+        setError(null);
+      } catch (err) {
+        const nextError = err instanceof Error ? err : new Error(String(err));
+        if (nextError.message.includes('Encryption manager is not initialized')) {
+          setStatus('idle');
+          setError(null);
+          return;
+        }
+        setStatus('error');
+        setError(nextError);
+      }
+    })();
+  }, [client]);
+
+  const run = useCallback(
+    async <T>(fn: (manager: any) => Promise<T>): Promise<T> => {
+      setStatus('working');
+      setError(null);
+      try {
+        const manager = requireEncryptionManager(client);
+        const result = await fn(manager);
+        const hasKey = !!manager.hasRecoveryKey?.();
+        const nextStatus = manager.getRecoveryStatus ? await manager.getRecoveryStatus() : null;
+        setHasRecoveryKey(hasKey);
+        setRecoveryStatus(nextStatus);
+        setStatus(nextStatus?.hasVault === false ? 'idle' : nextStatus?.unlocked ? 'ready' : 'locked');
+        return result;
+      } catch (err) {
+        const nextError = err instanceof Error ? err : new Error(String(err));
+        setError(nextError);
+        setStatus('error');
+        throw nextError;
+      }
+    },
+    [client],
+  );
+
+  const setupRecoveryPin = useCallback(
+    async (pin: string): Promise<void> => {
+      await run((manager) => manager.setupRecoveryPin(pin));
+    },
+    [run],
+  );
+
+  const unlockRecoveryVault = useCallback(
+    async (pin: string): Promise<void> => {
+      await run((manager) => manager.unlockRecoveryVault(pin));
+    },
+    [run],
+  );
+
+  const changeRecoveryPin = useCallback(
+    async (oldPin: string, newPin: string): Promise<void> => {
+      await run((manager) => manager.changeRecoveryPin(oldPin, newPin));
+    },
+    [run],
+  );
+
+  const changeUnlockedRecoveryPin = useCallback(
+    async (newPin: string): Promise<void> => {
+      await run((manager) => manager.changeUnlockedRecoveryPin(newPin));
+    },
+    [run],
+  );
+
+  const repairRecoveryChannel = useCallback(
+    (channelType: string, channelId: string, options?: { mode?: RepairMode }): Promise<RepairResult> =>
+      run((manager) => manager.repairRecoveryChannel(channelType, channelId, options)),
+    [run],
+  );
+
+  const repairEncryptedChannel = useCallback(
+    (
+      channelType: string,
+      channelId: string,
+      options?: { mode?: EncryptedChannelRepairMode },
+    ): Promise<EncryptedChannelRepairResult> =>
+      run((manager) => manager.repairEncryptedChannel(channelType, channelId, options)),
+    [run],
+  );
+
+  const restoreHistoricalMessages = useCallback(
+    (
+      channelType: string,
+      channelId: string,
+      options?: { fromEpoch?: number; toEpoch?: number },
+    ): Promise<RecoveryRestoredMessage[]> =>
+      run((manager) => manager.restoreHistoricalMessages(channelType, channelId, options)),
+    [run],
+  );
+
+  const enqueueRestore = useCallback(
+    (
+      channelType: string,
+      channelId: string,
+      priority: 'active' | 'background' = 'active',
+      options?: { fromEpoch?: number; toEpoch?: number },
+    ): void => {
+      try {
+        const manager = requireEncryptionManager(client);
+        manager.enqueueRestore?.(channelType, channelId, priority, options);
+        refresh();
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setStatus('error');
+      }
+    },
+    [client, refresh],
+  );
+
+  const loadRestoreProgress = useCallback(
+    async (channelType: string, channelId: string): Promise<RestoreProgressRecord | null> => {
+      try {
+        const manager = requireEncryptionManager(client);
+        return manager.getRestoreProgress ? await manager.getRestoreProgress(channelType, channelId) : null;
+      } catch (err) {
+        const nextError = err instanceof Error ? err : new Error(String(err));
+        if (!nextError.message.includes('Encryption manager is not initialized')) {
+          setError(nextError);
+        }
+        return null;
+      }
+    },
+    [client],
+  );
+
+  useEffect(() => {
+    const eventClient = client as any;
+    if (!eventClient?.on) return;
+    const progressSub = eventClient.on('e2ee.restore_progress' as any, refresh);
+    const bootstrapSub = eventClient.on('e2ee.bootstrap_progress' as any, refresh);
+    const initSub = eventClient.on('e2ee.initialized' as any, refresh);
+    return () => {
+      progressSub?.unsubscribe?.();
+      bootstrapSub?.unsubscribe?.();
+      initSub?.unsubscribe?.();
+    };
+  }, [client, refresh]);
+
+  useEffect(() => {
+    const eventClient = client as any;
+    if (!eventClient || eventClient.encryptionManager?.initialized) return;
+    const interval = setInterval(() => {
+      refresh();
+      if (eventClient.encryptionManager?.initialized) clearInterval(interval);
+    }, 500);
+    return () => clearInterval(interval);
+  }, [client, refresh]);
+
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  return useMemo(
+    () => ({
+      status,
+      error,
+      hasRecoveryKey,
+      recoveryStatus,
+      setupRecoveryPin,
+      unlockRecoveryVault,
+      changeRecoveryPin,
+      changeUnlockedRecoveryPin,
+      repairRecoveryChannel,
+      repairEncryptedChannel,
+      enqueueRestore,
+      loadRestoreProgress,
+      restoreHistoricalMessages,
+      refresh,
+    }),
+    [
+      status,
+      error,
+      hasRecoveryKey,
+      recoveryStatus,
+      setupRecoveryPin,
+      unlockRecoveryVault,
+      changeRecoveryPin,
+      changeUnlockedRecoveryPin,
+      repairRecoveryChannel,
+      repairEncryptedChannel,
+      enqueueRestore,
+      loadRestoreProgress,
+      restoreHistoricalMessages,
+      refresh,
+    ],
+  );
+};