refactor: consolidate duplicate account checking logic into unified utility

- Extract checkForDuplicateAccount methods from ImportAccountView and ImportDerivedAccountView
- Create unified utility function in src/libs/util.ts with TypeScript overloads
- Support both direct DID checking and mnemonic+derivation path checking
- Improve error handling with centralized logging via PlatformServiceFactory
- Add comprehensive JSDoc documentation for both function overloads
- Remove unused imports (deriveAddress, newIdentifier) from ImportAccountView

The utility function now provides a clean API:
- checkForDuplicateAccount(did) - for direct DID checking
- checkForDuplicateAccount(mnemonic, derivationPath) - for derivation + checking

Both components maintain identical functionality while using centralized logic.

src/libs/util.ts

@@ -1042,3 +1042,69 @@ export async function importFromMnemonic(
     }
   }
 }
+
+/**
+ * Checks if an account with the given DID already exists in the database
+ *
+ * @param did - The DID to check for duplicates
+ * @returns Promise<boolean> - True if account already exists, false otherwise
+ * @throws Error if database query fails
+ */
+export async function checkForDuplicateAccount(did: string): Promise<boolean>;
+
+/**
+ * Checks if an account with the given DID already exists in the database
+ *
+ * @param mnemonic - The mnemonic phrase to derive DID from
+ * @param derivationPath - The derivation path to use
+ * @returns Promise<boolean> - True if account already exists, false otherwise
+ * @throws Error if database query fails
+ */
+export async function checkForDuplicateAccount(
+  mnemonic: string,
+  derivationPath: string,
+): Promise<boolean>;
+
+/**
+ * Implementation of checkForDuplicateAccount with overloaded signatures
+ */
+export async function checkForDuplicateAccount(
+  didOrMnemonic: string,
+  derivationPath?: string,
+): Promise<boolean> {
+  try {
+    let didToCheck: string;
+
+    if (derivationPath) {
+      // Derive the DID from mnemonic and derivation path
+      const [address, privateHex, publicHex] = deriveAddress(
+        didOrMnemonic.trim().toLowerCase(),
+        derivationPath,
+      );
+
+      const newId = newIdentifier(
+        address,
+        privateHex,
+        publicHex,
+        derivationPath,
+      );
+      didToCheck = newId.did;
+    } else {
+      // Use the provided DID directly
+      didToCheck = didOrMnemonic;
+    }
+
+    // Check if an account with this DID already exists
+    const platformService = await getPlatformService();
+    const existingAccount = await platformService.dbQuery(
+      "SELECT did FROM accounts WHERE did = ?",
+      [didToCheck],
+    );
+
+    return (existingAccount?.values?.length ?? 0) > 0;
+  } catch (error) {
+    // If we can't check for duplicates, let the calling process handle the error
+    logger.error("Error checking for duplicate account:", error);
+    throw error;
+  }
+}