feat(vault): add get/create assets API in workflow

TODO: update vault.service.ts. Use MNEMONIC workflow to create real private_key_shard and content_inner_encrypted

src/hooks/useVaultAssets.ts

@@ -0,0 +1,160 @@
+/**
+ * useVaultAssets: Encapsulates /assets/get and /assets/create for VaultScreen.
+ * - Fetches assets when vault is unlocked and token exists.
+ * - Exposes createAsset with 401/network error handling and list refresh on success.
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import * as bip39 from 'bip39';
+import { useAuth } from '../context/AuthContext';
+import { assetsService } from '../services/assets.service';
+import { createAssetPayload } from '../services/vault.service';
+import {
+  initialVaultAssets,
+  mapApiAssetsToVaultAssets,
+  type ApiAsset,
+} from '../utils/vaultAssets';
+import type { VaultAsset } from '../types';
+
+// -----------------------------------------------------------------------------
+// Types
+// -----------------------------------------------------------------------------
+
+export interface CreateAssetResult {
+  success: boolean;
+  isUnauthorized?: boolean;
+  error?: string;
+}
+
+export interface UseVaultAssetsReturn {
+  /** Current list (mock until API succeeds) */
+  assets: VaultAsset[];
+  /** Replace list (e.g. after external refresh) */
+  setAssets: React.Dispatch<React.SetStateAction<VaultAsset[]>>;
+  /** Refetch from GET /assets/get */
+  refreshAssets: () => Promise<void>;
+  /** Create asset via POST /assets/create; on success refreshes list */
+  createAsset: (params: { title: string; content: string }) => Promise<CreateAssetResult>;
+  /** True while create request is in flight */
+  isSealing: boolean;
+  /** Error message from last create failure (non-401) */
+  createError: string | null;
+  /** Clear createError */
+  clearCreateError: () => void;
+}
+
+// -----------------------------------------------------------------------------
+// Hook
+// -----------------------------------------------------------------------------
+
+/**
+ * Vault assets list + create. Fetches on unlock when token exists; keeps mock on error.
+ */
+export function useVaultAssets(isUnlocked: boolean): UseVaultAssetsReturn {
+  const { token, signOut } = useAuth();
+  const [assets, setAssets] = useState<VaultAsset[]>(initialVaultAssets);
+  const [isSealing, setIsSealing] = useState(false);
+  const [createError, setCreateError] = useState<string | null>(null);
+
+  const refreshAssets = useCallback(async () => {
+    if (!token) return;
+    try {
+      const list = await assetsService.getMyAssets(token);
+      if (Array.isArray(list)) {
+        setAssets(mapApiAssetsToVaultAssets(list as ApiAsset[]));
+      }
+    } catch {
+      // Keep current assets (mock or previous fetch)
+    }
+  }, [token]);
+
+  // Fetch list when unlocked and token exists
+  useEffect(() => {
+    if (!isUnlocked || !token) return;
+    let cancelled = false;
+    assetsService
+      .getMyAssets(token)
+      .then((list) => {
+        if (!cancelled && Array.isArray(list)) {
+          setAssets(mapApiAssetsToVaultAssets(list as ApiAsset[]));
+        }
+      })
+      .catch(() => {
+        // Keep initial (mock) assets
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [isUnlocked, token]);
+
+  const createAsset = useCallback(
+    async ({
+      title,
+      content,
+    }: {
+      title: string;
+      content: string;
+    }): Promise<CreateAssetResult> => {
+      if (!token) {
+        return { success: false, error: 'Not logged in.' };
+      }
+      setIsSealing(true);
+      setCreateError(null);
+      try {
+        const wordList = bip39.wordlists.english;
+        const payload = await createAssetPayload(
+          title.trim(),
+          content.trim(),
+          wordList,
+          'note',
+          0
+        );
+        await assetsService.createAsset(
+          {
+            title: payload.title,
+            private_key_shard: payload.private_key_shard,
+            content_inner_encrypted: payload.content_inner_encrypted,
+          },
+          token
+        );
+        await refreshAssets();
+        return { success: true };
+      } catch (err: unknown) {
+        const status =
+          err && typeof err === 'object' && 'status' in err
+            ? (err as { status?: number }).status
+            : undefined;
+        const rawMessage =
+          err instanceof Error ? err.message : String(err ?? 'Failed to create.');
+        const isUnauthorized =
+          status === 401 || /401|Unauthorized/i.test(rawMessage);
+
+        if (isUnauthorized) {
+          signOut();
+          return { success: false, isUnauthorized: true };
+        }
+
+        const friendlyMessage = /failed to fetch|network error/i.test(rawMessage)
+          ? 'Network error. Please check that the backend is running and reachable (see API_BASE_URL in config).'
+          : rawMessage;
+        setCreateError(friendlyMessage);
+        return { success: false, error: friendlyMessage };
+      } finally {
+        setIsSealing(false);
+      }
+    },
+    [token, refreshAssets, signOut]
+  );
+
+  const clearCreateError = useCallback(() => setCreateError(null), []);
+
+  return {
+    assets,
+    setAssets,
+    refreshAssets,
+    createAsset,
+    isSealing,
+    createError,
+    clearCreateError,
+  };
+}