fix: retry vault read on resume-window IPC failure to prevent false sign-out

infrastructure/eid-wallet/package.json

@@ -14,6 +14,7 @@
         "lint": "npx @biomejs/biome lint --write ./src",
         "check-lint": "npx @biomejs/biome lint ./src",
         "tauri": "tauri",
+        "test": "vitest run",
         "storybook": "svelte-kit sync && storybook dev -p 6006",
         "build-storybook": "storybook build",
         "build:apk": "npm run tauri android build -- --apk --target aarch64 --target armv7",

infrastructure/eid-wallet/src/lib/global/controllers/evault.spec.ts

@@ -0,0 +1,86 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+// evault.ts imports these at runtime; mock them so the module loads in a plain
+// Node test env without pulling Tauri / wallet-sdk internals.
+vi.mock("wallet-sdk", () => ({ syncPublicKeyToEvault: vi.fn() }));
+vi.mock("../../services/NotificationService", () => ({
+    default: {
+        getInstance: () => ({ registerDevice: vi.fn(async () => true) }),
+    },
+}));
+
+import { VaultController } from "./evault";
+
+const VAULT = { ename: "user@w3id.example", uri: "https://evault.example" };
+
+/** Build a VaultController whose only exercised dependency is `store.get`. */
+function makeController(get: (key: string) => Promise<unknown>) {
+    const store = { get } as unknown as ConstructorParameters<
+        typeof VaultController
+    >[0];
+    const userController = {
+        user: Promise.resolve(undefined),
+    } as unknown as ConstructorParameters<typeof VaultController>[1];
+    return new VaultController(store, userController);
+}
+
+afterEach(() => {
+    vi.useRealTimers();
+});
+
+describe("VaultController.vault — #readVaultResilient retry behavior", () => {
+    it("returns immediately for a resolved undefined (genuine logout), no retry", async () => {
+        const get = vi.fn(async () => undefined);
+        const vc = makeController(get);
+
+        await expect(vc.vault).resolves.toBeUndefined();
+        expect(get).toHaveBeenCalledTimes(1); // no retry when the key is simply absent
+    });
+
+    it("retries thrown store errors up to maxAttempts, then returns undefined without throwing", async () => {
+        vi.useFakeTimers();
+        const get = vi.fn(async () => {
+            throw new Error(
+                "Fetch API cannot load ipc://localhost/plugin:store|get",
+            );
+        });
+        const vc = makeController(get);
+
+        const result = vc.vault;
+        await vi.runAllTimersAsync(); // skip the 200ms backoffs
+
+        await expect(result).resolves.toBeUndefined();
+        expect(get).toHaveBeenCalledTimes(10); // maxAttempts
+    });
+
+    it("recovers the vault when the store IPC comes back mid-retry", async () => {
+        vi.useFakeTimers();
+        let calls = 0;
+        const get = vi.fn(async () => {
+            if (calls++ < 6) throw new Error("IPC custom protocol failed");
+            return VAULT;
+        });
+        const vc = makeController(get);
+
+        const result = vc.vault;
+        await vi.runAllTimersAsync();
+
+        await expect(result).resolves.toEqual(VAULT);
+        expect(get).toHaveBeenCalledTimes(7);
+    });
+
+    it("coalesces concurrent reads into a single in-flight store read", async () => {
+        const get = vi.fn(async () => VAULT);
+        const vc = makeController(get);
+
+        const [a, b] = await Promise.all([vc.vault, vc.vault]);
+
+        expect(a).toEqual(VAULT);
+        expect(b).toEqual(VAULT);
+        expect(get).toHaveBeenCalledTimes(1); // both callers shared one read
+
+        // ...and a later, independent access performs a fresh read.
+        await vc.vault;
+        expect(get).toHaveBeenCalledTimes(2);
+    });
+});

infrastructure/eid-wallet/src/lib/global/controllers/evault.ts

@@ -580,19 +580,58 @@ export class VaultController {
         }
     }
 
+    #vaultReadInFlight: Promise<Record<string, string> | undefined> | null =
+        null;
+
     get vault() {
-        return this.#store
-            .get<Record<string, string>>("vault")
-            .then((vault) => {
-                if (!vault) {
+        // Coalesce concurrent reads so the resume window doesn't spin one
+        // retry loop per caller; cleared on settle so later reads are fresh.
+        if (this.#vaultReadInFlight) return this.#vaultReadInFlight;
+        const read = this.#readVaultResilient().finally(() => {
+            this.#vaultReadInFlight = null;
+        });
+        this.#vaultReadInFlight = read;
+        return read;
+    }
+
+    /**
+     * Read the persisted vault, distinguishing "no vault" (resolved `undefined`
+     * → genuine logout) from a transient store IPC failure (a throw).
+     *
+     * On iOS the `ipc://localhost` protocol is briefly torn down after the app
+     * resumes from background, so `plugin:store|get` throws. The old getter
+     * swallowed that into `undefined` — indistinguishable from "never logged
+     * in" — so route guards redirected to /login: the intermittent sign-out.
+     *
+     * We retry on THROW so the resume window passes before reporting "no vault".
+     * A genuine logout resolves `undefined` (no throw) and returns immediately.
+     * Still never throws, still returns `Record | undefined` — callers unchanged.
+     */
+    async #readVaultResilient(): Promise<Record<string, string> | undefined> {
+        const maxAttempts = 10;
+        const retryDelayMs = 200; // ~2s total budget covers the IPC-dead window
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                const vault =
+                    await this.#store.get<Record<string, string>>("vault");
+                return vault ?? undefined;
+            } catch (error) {
+                if (attempt === maxAttempts) {
+                    console.error(
+                        "Failed to get vault after retries (store IPC unavailable):",
+                        error,
+                    );
                     return undefined;
                 }
-                return vault;
-            })
-            .catch((error) => {
-                console.error("Failed to get vault:", error);
-                return undefined;
-            });
+                console.warn(
+                    `[VaultController] vault read failed (attempt ${attempt}/${maxAttempts}), store IPC likely re-initializing after resume — retrying...`,
+                );
+                await new Promise((resolve) =>
+                    setTimeout(resolve, retryDelayMs),
+                );
+            }
+        }
+        return undefined;
     }
 
     // Getters for internal properties

infrastructure/eid-wallet/src/test/env-static-public.ts

@@ -0,0 +1,6 @@
+// Test stub for SvelteKit's `$env/static/public` (aliased in vitest.config.ts).
+// Real values are injected by SvelteKit at build time; tests only need the
+// symbols to exist so modules that import them can load.
+export const PUBLIC_EID_WALLET_TOKEN = "";
+export const PUBLIC_PROVISIONER_URL = "";
+export const PUBLIC_REGISTRY_URL = "";

infrastructure/eid-wallet/vitest.config.ts

@@ -0,0 +1,20 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+// Dedicated, isolated test config — intentionally does NOT load the app's
+// Svelte/Tauri/Tailwind plugins. Unit tests here run in a plain Node
+// environment and stub the few runtime-only imports (see `$env` alias below;
+// heavier deps are mocked per-spec with `vi.mock`).
+export default defineConfig({
+    resolve: {
+        alias: {
+            "$env/static/public": fileURLToPath(
+                new URL("./src/test/env-static-public.ts", import.meta.url),
+            ),
+        },
+    },
+    test: {
+        environment: "node",
+        include: ["src/**/*.spec.ts"],
+    },
+});