From f146295d3721c62ed6e5860c9c332fd2c32d4da7 Mon Sep 17 00:00:00 2001
From: Bekiboo <julien.connault@gmail.com>
Date: Fri, 25 Sep 2026 12:39:15 +0300
Subject: [PATCH 1/5] fix(eid-wallet): close the social request sheet instead
 of declining it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The × on the "Social Connection Request" sheet was wired to decline(),
which deletes the binding document from the vault — a button labelled
"Close" destroyed the incoming invite. It now dismisses the sheet and
leaves the request pending; Decline stays the only path that deletes.

Closes #1161
---
 .../src/routes/(app)/main/components/SocialBindingDrawer.svelte | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
index d63137452..5c1eee8e2 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
@@ -259,7 +259,7 @@ onDestroy(stopPolling);
             </h3>
             <button
                 type="button"
-                onclick={decline}
+                onclick={close}
                 aria-label={m.common_close()}
                 class="w-9 h-9 rounded-full bg-black-50 flex items-center justify-center text-black-700 active:opacity-70 shrink-0"
             >

From 55d6cf6fd7f5f9990b35f252a47cbf9764c10565 Mon Sep 17 00:00:00 2001
From: Bekiboo <julien.connault@gmail.com>
Date: Fri, 25 Sep 2026 12:40:38 +0300
Subject: [PATCH 2/5] fix(eid-wallet): surface an incoming social request on
 the home screen
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An incoming request was only ever detected by the invite drawer's poll,
which runs every 3s while that drawer is open and showing the QR. Close
the QR before the next tick and nothing looked for the request again —
the home screen's passive refresh only recomputes the bindings count and
name preview, where a pending invite is indistinguishable from a
completed binding.

/main now looks for a pending request on the plumbing it already has: the
30s bindings refresh, the visibilitychange listener and pull-to-refresh.
When it finds one it opens the drawer straight into the consent prompt,
but only while /main is visible with no other sheet and no welcome tour
on screen. A request closed unanswered isn't prompted again for the rest
of the session; it stays in the vault and in the bindings list, where it
can still be accepted or declined.

findPendingSocialRequest wraps fetchUnsignedSocialDocs so both the drawer
poll and the home screen pick the same request, oldest first.

Closes #1163
---
 .../eid-wallet/src/lib/utils/index.ts         |  1 +
 .../src/lib/utils/pendingSocialRequest.ts     | 46 +++++++++
 .../src/lib/utils/socialBinding.spec.ts       | 61 ++++++++++++
 .../src/routes/(app)/main/+page.svelte        | 58 ++++++++++++
 .../components/SocialBindingDrawer.svelte     | 94 +++++++++++++------
 5 files changed, 231 insertions(+), 29 deletions(-)
 create mode 100644 infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts

diff --git a/infrastructure/eid-wallet/src/lib/utils/index.ts b/infrastructure/eid-wallet/src/lib/utils/index.ts
index c61d27e9c..670bf6eb1 100644
--- a/infrastructure/eid-wallet/src/lib/utils/index.ts
+++ b/infrastructure/eid-wallet/src/lib/utils/index.ts
@@ -7,3 +7,4 @@ export * from "./bindingDocHash";
 export * from "./socialBinding";
 export * from "./portal";
 export * from "./identityLabels";
+export * from "./pendingSocialRequest";
diff --git a/infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts b/infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts
new file mode 100644
index 000000000..24b8c50e7
--- /dev/null
+++ b/infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts
@@ -0,0 +1,46 @@
+import {
+    type BindingDocParsed,
+    fetchUnsignedSocialDocs,
+} from "./socialBinding";
+
+export interface PendingSocialRequest {
+    docId: string;
+    parsed: BindingDocParsed;
+    signerEname: string;
+}
+
+/**
+ * The pending social connection request to prompt for next, or null.
+ *
+ * Oldest first, so a backlog is worked through in the order it arrived.
+ * `dismissedDocIds` holds the requests the user closed without answering;
+ * they stay in the vault and in the bindings list, they just don't prompt
+ * again. Envelopes fetchUnsignedSocialDocs hides stay hidden.
+ */
+export async function findPendingSocialRequest(
+    ownGqlUrl: string,
+    callerEname: string,
+    dismissedDocIds: ReadonlySet<string> = new Set<string>(),
+): Promise<PendingSocialRequest | null> {
+    const edges = await fetchUnsignedSocialDocs(ownGqlUrl, callerEname);
+
+    let oldest: PendingSocialRequest | null = null;
+    let oldestSentAt = "";
+
+    for (const edge of edges) {
+        if (dismissedDocIds.has(edge.node.id)) continue;
+        const parsed = edge.node.parsed;
+        const signature = parsed?.signatures?.[0];
+        if (!parsed || !signature?.signer) continue;
+        const sentAt = signature.timestamp ?? "";
+        if (oldest !== null && sentAt >= oldestSentAt) continue;
+        oldest = {
+            docId: edge.node.id,
+            parsed,
+            signerEname: signature.signer,
+        };
+        oldestSentAt = sentAt;
+    }
+
+    return oldest;
+}
diff --git a/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts b/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts
index b9ee1ccca..19c66dd86 100644
--- a/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts
+++ b/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts
@@ -5,6 +5,7 @@ vi.mock("$env/static/public", () => ({
     PUBLIC_REGISTRY_URL: "https://registry.test/",
 }));
 
+import { findPendingSocialRequest } from "./pendingSocialRequest";
 import {
     CANCEL_NOT_PENDING,
     ENAME_NOT_FOUND,
@@ -20,6 +21,7 @@ import {
 
 const ME = "@me";
 const BOB = "@bob";
+const CAROL = "@carol";
 
 interface Sig {
     signer: string;
@@ -484,5 +486,64 @@ describe("resolveVaultUri", () => {
         await expect(resolveVaultUri("@nobody")).rejects.toThrow(
             ENAME_NOT_FOUND,
         );
+
+describe("choosing the request to prompt for", () => {
+    beforeEach(() => {
+        vaults.set(ME, [
+            doc("P1", ME, [CAROL, ME], [{ signer: CAROL, timestamp: at(10) }]),
+            doc("P2", ME, [BOB, ME], [{ signer: BOB, timestamp: at(40) }]),
+        ]);
+    });
+
+    it("takes the oldest request first", async () => {
+        const request = await findPendingSocialRequest(gql(ME), ME);
+        expect(request?.docId).toBe("P2");
+        expect(request?.signerEname).toBe(BOB);
+        expect(request?.parsed.subject).toBe(ME);
+    });
+
+    it("moves on to the next request when one was dismissed", async () => {
+        const request = await findPendingSocialRequest(
+            gql(ME),
+            ME,
+            new Set(["P2"]),
+        );
+        expect(request?.docId).toBe("P1");
+    });
+
+    it("stops prompting once every request has been dismissed", async () => {
+        const request = await findPendingSocialRequest(
+            gql(ME),
+            ME,
+            new Set(["P1", "P2"]),
+        );
+        expect(request).toBeNull();
+        expect(deletes).toEqual([]);
+    });
+
+    it("leaves a dismissed request in the vault", async () => {
+        await findPendingSocialRequest(gql(ME), ME, new Set(["P1", "P2"]));
+        expect((vaults.get(ME) as Doc[]).map((d) => d.id)).toEqual([
+            "P1",
+            "P2",
+        ]);
+    });
+
+    it("does not prompt for an envelope the poll hides", async () => {
+        vaults.set(ME, [
+            doc(
+                "D1",
+                ME,
+                [BOB, ME],
+                [
+                    { signer: BOB, timestamp: at(190) },
+                    { signer: ME, timestamp: at(180) },
+                ],
+            ),
+            doc("D2", ME, [BOB, ME], [{ signer: BOB, timestamp: at(185) }]),
+        ]);
+
+        expect(await findPendingSocialRequest(gql(ME), ME)).toBeNull();
+        expect(deletes).toEqual([]);
     });
 });
diff --git a/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte b/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
index 6f6af1aca..7e2b0d8a0 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
@@ -23,6 +23,11 @@ let cachedSelfDocId: string | undefined;
 let cachedSocialBindingCount = 0;
 let cachedSocialBindingPreview: SocialBindingDisplay[] = [];
 let hasEverLoaded = false;
+
+// Requests the user closed without answering. Module-scope so leaving /main and
+// coming back doesn't prompt for them again; an app restart clears them, and
+// they stay answerable from the bindings list either way.
+const dismissedSocialRequestIds = new Set<string>();
 </script>
 
 <script lang="ts">
@@ -42,8 +47,10 @@ import * as Button from "$lib/ui/Button";
 import { isPermissionGranted } from "@choochmeque/tauri-plugin-notifications-api";
 import { openAppSettings } from "@tauri-apps/plugin-barcode-scanner";
 import {
+    type PendingSocialRequest,
     fetchNameFromVault,
     fetchReconciledSocialBindings,
+    findPendingSocialRequest,
     resolveVaultUri,
 } from "$lib/utils";
 import { getCanonicalBindingDocString } from "$lib/utils/bindingDocHash";
@@ -132,6 +139,7 @@ const bindingDiagram = $derived([
 let eVaultInfoOpen = $state(false);
 let bindingDocsInfoOpen = $state(false);
 let socialDrawerOpen = $state(false);
+let pendingSocialRequest = $state<PendingSocialRequest | null>(null);
 // True while loadBindingDocuments + loadPersonalIntoStore are still in flight.
 // Starts as false on re-entries (cached data paints instantly) and true only
 // on first-ever mount where nothing is cached yet.
@@ -518,6 +526,7 @@ async function loadSocialBindings(): Promise<void> {
 }
 
 function openSocialDrawer() {
+    pendingSocialRequest = null;
     socialDrawerOpen = true;
 }
 
@@ -525,6 +534,50 @@ async function handleSocialBound() {
     await loadSocialBindings();
 }
 
+// An incoming request opens its own sheet, so only prompt when /main is in
+// front of the user and nothing else is holding the screen.
+function canPromptSocialRequest(): boolean {
+    if (!globalState || !pageReady || tourStep !== null) return false;
+    if (typeof document !== "undefined" && document.hidden) return false;
+    return !(
+        socialDrawerOpen ||
+        showNotifPrompt ||
+        editNameOpen ||
+        kycOpen ||
+        eVaultInfoOpen ||
+        bindingDocsInfoOpen
+    );
+}
+
+async function checkPendingSocialRequest(): Promise<void> {
+    if (!canPromptSocialRequest()) return;
+    try {
+        const vault = await globalState?.vaultController.vault;
+        if (!vault?.uri || !vault?.ename) return;
+        const callerEname = vault.ename.startsWith("@")
+            ? vault.ename
+            : `@${vault.ename}`;
+        const gqlUrl = new URL("/graphql", vault.uri).toString();
+
+        const request = await findPendingSocialRequest(
+            gqlUrl,
+            callerEname,
+            dismissedSocialRequestIds,
+        );
+        // Re-checked after the round trip: the user may have opened something
+        // else while it was in flight.
+        if (!request || !canPromptSocialRequest()) return;
+        pendingSocialRequest = request;
+        socialDrawerOpen = true;
+    } catch (err) {
+        console.warn("[main] Failed to check for social requests:", err);
+    }
+}
+
+function handleSocialRequestDismissed(docId: string) {
+    dismissedSocialRequestIds.add(docId);
+}
+
 function openSocialFullList() {
     goto("/social-bindings");
 }
@@ -885,6 +938,8 @@ onMount(() => {
         // tour — defer to when the user has dismissed it. For returning users
         // (tour already seen) it fires right away.
         await maybeShowNotifPrompt(seen);
+
+        void checkPendingSocialRequest();
     })();
 
     const checkStatus = () => {
@@ -945,6 +1000,7 @@ async function refreshBindings(): Promise<void> {
             loadUserInfo(),
             loadBindingDocuments(),
             loadPersonalIntoStore(),
+            checkPendingSocialRequest(),
         ]);
     } catch (err) {
         console.warn("[main] passive refresh failed:", err);
@@ -1179,7 +1235,9 @@ async function refreshBindings(): Promise<void> {
 <SocialBindingDrawer
     bind:isOpen={socialDrawerOpen}
     {globalState}
+    request={pendingSocialRequest}
     onbound={handleSocialBound}
+    ondismiss={handleSocialRequestDismissed}
 />
 
 <EditNameSheet
diff --git a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
index 5c1eee8e2..7c8c4aaab 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
@@ -4,13 +4,14 @@ import { m } from "$lib/i18n";
 import { BottomSheet, ButtonAction } from "$lib/ui";
 import {
     type BindingDocParsed,
+    type PendingSocialRequest,
     acceptSocialBinding,
     declineSocialBinding,
     fetchNameFromVault,
-    fetchUnsignedSocialDocs,
+    findPendingSocialRequest,
     resolveVaultUri,
 } from "$lib/utils";
-import { onDestroy } from "svelte";
+import { onDestroy, untrack } from "svelte";
 import { Shadow } from "svelte-loading-spinners";
 import QrCode from "svelte-qrcode";
 
@@ -18,12 +19,21 @@ interface ISocialBindingDrawerProps {
     isOpen: boolean;
     globalState: GlobalState | undefined;
     onbound?: () => void;
+    /**
+     * When set at open time, the drawer shows the consent prompt for this
+     * request instead of the invite QR. Read once, when isOpen flips to true.
+     */
+    request?: PendingSocialRequest | null;
+    /** The request was closed unanswered and is still pending. */
+    ondismiss?: (docId: string) => void;
 }
 
 let {
     isOpen = $bindable(false),
     globalState,
     onbound,
+    request = null,
+    ondismiss,
 }: ISocialBindingDrawerProps = $props();
 
 type Phase =
@@ -40,6 +50,9 @@ let pendingDocId = $state<string | null>(null);
 let pendingDocParsed = $state<BindingDocParsed | null>(null);
 let signerEname = $state<string | null>(null);
 let signerName = $state<string | null>(null);
+// Opened on an incoming request rather than on the invite QR, so there is no
+// QR to fall back to once the request is answered.
+let openedFromRequest = $state(false);
 
 let pollInterval: ReturnType<typeof setInterval> | null = null;
 
@@ -68,36 +81,29 @@ async function poll() {
             : `@${vault.ename}`;
         const gqlUrl = new URL("/graphql", vault.uri).toString();
 
-        const unsigned = await fetchUnsignedSocialDocs(gqlUrl, callerEname);
-        if (unsigned.length === 0) return;
-
-        const doc = unsigned[0];
-        const parsed = doc.node.parsed;
-        if (!parsed) return;
-        const signer = parsed.signatures[0]?.signer ?? null;
-        if (!signer) return;
+        const pending = await findPendingSocialRequest(gqlUrl, callerEname);
+        if (!pending) return;
 
         stopPolling();
-        signerEname = signer;
-        pendingDocId = doc.node.id;
-        pendingDocParsed = parsed;
-
-        try {
-            const signerVaultUri = await resolveVaultUri(signer);
-            signerName = await fetchNameFromVault(
-                signerVaultUri,
-                signer,
-                signer,
-            );
-        } catch {
-            signerName = signer;
-        }
+        signerEname = pending.signerEname;
+        pendingDocId = pending.docId;
+        pendingDocParsed = pending.parsed;
         phase = "awaiting-consent";
+        await resolveSignerName(pending.signerEname);
     } catch (err) {
         console.error("[SocialBindingDrawer] poll error:", err);
     }
 }
 
+async function resolveSignerName(signer: string) {
+    try {
+        const signerVaultUri = await resolveVaultUri(signer);
+        signerName = await fetchNameFromVault(signerVaultUri, signer, signer);
+    } catch {
+        signerName = signer;
+    }
+}
+
 async function confirm() {
     const gs = globalState;
     if (!gs || !pendingDocId || !pendingDocParsed) return;
@@ -171,6 +177,10 @@ async function decline() {
         }
     }
 
+    if (openedFromRequest) {
+        isOpen = false;
+        return;
+    }
     phase = "qr";
     startPolling();
 }
@@ -181,22 +191,47 @@ function close() {
 
 function retryFromError() {
     errorMessage = null;
+    if (pendingDocId && pendingDocParsed) {
+        phase = "awaiting-consent";
+        return;
+    }
     phase = "qr";
     startPolling();
 }
 
-// Drive the drawer lifecycle from isOpen.
+// Drive the drawer lifecycle from isOpen. `request` is read inside untrack so
+// the parent clearing it can't restart the drawer mid-flow.
 $effect(() => {
-    if (isOpen) {
-        void initFromVault();
-    } else {
+    const open = isOpen;
+    untrack(() => {
+        if (open) {
+            void initFromVault();
+            return;
+        }
         stopPolling();
+        // Closing on a request leaves it pending rather than declining it;
+        // tell the parent so its poll doesn't prompt for the same one again.
+        if (phase === "awaiting-consent" && pendingDocId) {
+            ondismiss?.(pendingDocId);
+        }
         reset();
-    }
+    });
 });
 
 async function initFromVault() {
     if (!globalState) return;
+
+    const incoming = request;
+    if (incoming) {
+        openedFromRequest = true;
+        pendingDocId = incoming.docId;
+        pendingDocParsed = incoming.parsed;
+        signerEname = incoming.signerEname;
+        phase = "awaiting-consent";
+        await resolveSignerName(incoming.signerEname);
+        return;
+    }
+
     const vault = await globalState.vaultController.vault;
     if (!vault?.ename) return;
     const ename = vault.ename.startsWith("@") ? vault.ename : `@${vault.ename}`;
@@ -213,6 +248,7 @@ function reset() {
     pendingDocParsed = null;
     signerEname = null;
     signerName = null;
+    openedFromRequest = false;
 }
 
 onDestroy(stopPolling);

From 85e82820910658a4f59d8e52e6ebbaebe3e498d0 Mon Sep 17 00:00:00 2001
From: Bekiboo <julien.connault@gmail.com>
Date: Fri, 25 Sep 2026 15:56:38 +0300
Subject: [PATCH 3/5] fix(eid-wallet): address review on the incoming request
 prompt

The QR poll ignored the session's dismissed ids, so reopening the sheet
re-prompted for a request the user had just closed.

A signer-name lookup from a superseded request could land last and label the
prompt with the wrong person.

decline() closed the sheet even when the deletion failed, so a still-pending
request looked declined and came back at the next refresh. It now keeps the
request on screen with a retry.

Closing the QR sheet checks once more, instead of leaving a request that
arrived mid-poll to the 30s refresh.
---
 .../src/routes/(app)/main/+page.svelte        | 16 +++-
 .../components/SocialBindingDrawer.svelte     | 73 ++++++++++++-------
 2 files changed, 61 insertions(+), 28 deletions(-)

diff --git a/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte b/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
index 7e2b0d8a0..80e4fee9b 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
@@ -60,7 +60,7 @@ import {
     deletePersonalBinding,
     loadPersonalBindings,
 } from "$lib/utils/personalBinding";
-import { getContext, onDestroy, onMount, tick } from "svelte";
+import { getContext, onDestroy, onMount, tick, untrack } from "svelte";
 import { Shadow } from "svelte-loading-spinners";
 import { fly } from "svelte/transition";
 import AppsMarketplace from "./components/AppsMarketplace.svelte";
@@ -578,6 +578,19 @@ function handleSocialRequestDismissed(docId: string) {
     dismissedSocialRequestIds.add(docId);
 }
 
+// The sheet's own poll can miss a request that lands just before the user
+// closes the QR, so check again on the way out instead of leaving it to the
+// 30s refresh. Requests already dismissed are skipped, so this cannot reopen
+// what the user just closed.
+let socialDrawerWasOpen = false;
+$effect(() => {
+    const open = socialDrawerOpen;
+    untrack(() => {
+        if (socialDrawerWasOpen && !open) void checkPendingSocialRequest();
+        socialDrawerWasOpen = open;
+    });
+});
+
 function openSocialFullList() {
     goto("/social-bindings");
 }
@@ -1236,6 +1249,7 @@ async function refreshBindings(): Promise<void> {
     bind:isOpen={socialDrawerOpen}
     {globalState}
     request={pendingSocialRequest}
+    dismissedIds={dismissedSocialRequestIds}
     onbound={handleSocialBound}
     ondismiss={handleSocialRequestDismissed}
 />
diff --git a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
index 7c8c4aaab..d9573a2bd 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
@@ -26,6 +26,11 @@ interface ISocialBindingDrawerProps {
     request?: PendingSocialRequest | null;
     /** The request was closed unanswered and is still pending. */
     ondismiss?: (docId: string) => void;
+    /**
+     * Requests closed unanswered this session. The QR poll skips them too, so
+     * reopening the sheet does not re-prompt for one the user just closed.
+     */
+    dismissedIds?: ReadonlySet<string>;
 }
 
 let {
@@ -34,6 +39,7 @@ let {
     onbound,
     request = null,
     ondismiss,
+    dismissedIds,
 }: ISocialBindingDrawerProps = $props();
 
 type Phase =
@@ -81,7 +87,11 @@ async function poll() {
             : `@${vault.ename}`;
         const gqlUrl = new URL("/graphql", vault.uri).toString();
 
-        const pending = await findPendingSocialRequest(gqlUrl, callerEname);
+        const pending = await findPendingSocialRequest(
+            gqlUrl,
+            callerEname,
+            dismissedIds,
+        );
         if (!pending) return;
 
         stopPolling();
@@ -89,19 +99,23 @@ async function poll() {
         pendingDocId = pending.docId;
         pendingDocParsed = pending.parsed;
         phase = "awaiting-consent";
-        await resolveSignerName(pending.signerEname);
+        await resolveSignerName(pending.signerEname, pending.docId);
     } catch (err) {
         console.error("[SocialBindingDrawer] poll error:", err);
     }
 }
 
-async function resolveSignerName(signer: string) {
+// Two lookups overlap when one request replaces another, and the older one can
+// land last. Only the request still on screen gets its name.
+async function resolveSignerName(signer: string, docId: string) {
+    let name = signer;
     try {
         const signerVaultUri = await resolveVaultUri(signer);
-        signerName = await fetchNameFromVault(signerVaultUri, signer, signer);
+        name = await fetchNameFromVault(signerVaultUri, signer, signer);
     } catch {
-        signerName = signer;
+        // Fall back to the eName.
     }
+    if (pendingDocId === docId) signerName = name;
 }
 
 async function confirm() {
@@ -143,40 +157,45 @@ async function confirm() {
 async function decline() {
     const docId = pendingDocId;
     const declinedDoc = pendingDocParsed;
-    pendingDocId = null;
-    pendingDocParsed = null;
-    signerEname = null;
-    signerName = null;
 
     if (docId && globalState) {
         try {
             const vault = await globalState.vaultController.vault;
-            if (vault?.ename && vault?.uri) {
-                const callerEname = vault.ename.startsWith("@")
-                    ? vault.ename
-                    : `@${vault.ename}`;
-                const gqlUrl = new URL("/graphql", vault.uri).toString();
-                await declineSocialBinding(
-                    gqlUrl,
-                    callerEname,
-                    docId,
-                    declinedDoc,
-                );
-
-                // The declined request was counted as a (pending) binding on
-                // the home screen; now that it's gone, tell the parent to
-                // re-fetch so the count drops immediately (e.g. 10 → 9)
-                // instead of staying stale until the next manual refresh.
-                onbound?.();
+            if (!vault?.ename || !vault?.uri) {
+                throw new Error(m.social_drawer_no_vault());
             }
+            const callerEname = vault.ename.startsWith("@")
+                ? vault.ename
+                : `@${vault.ename}`;
+            const gqlUrl = new URL("/graphql", vault.uri).toString();
+            await declineSocialBinding(gqlUrl, callerEname, docId, declinedDoc);
+
+            // The declined request was counted as a (pending) binding on the
+            // home screen; now that it's gone, tell the parent to re-fetch so
+            // the count drops immediately (e.g. 10 → 9) instead of staying
+            // stale until the next manual refresh.
+            onbound?.();
         } catch (err) {
+            // The document is still in the vault, so keep the request on
+            // screen with a retry rather than closing as if it were declined.
             console.error(
                 "[SocialBindingDrawer] failed to delete declined doc:",
                 err,
             );
+            errorMessage =
+                err instanceof Error
+                    ? err.message
+                    : m.social_drawer_error_generic();
+            phase = "error";
+            return;
         }
     }
 
+    pendingDocId = null;
+    pendingDocParsed = null;
+    signerEname = null;
+    signerName = null;
+
     if (openedFromRequest) {
         isOpen = false;
         return;
@@ -228,7 +247,7 @@ async function initFromVault() {
         pendingDocParsed = incoming.parsed;
         signerEname = incoming.signerEname;
         phase = "awaiting-consent";
-        await resolveSignerName(incoming.signerEname);
+        await resolveSignerName(incoming.signerEname, incoming.docId);
         return;
     }
 

From f2e43d59cfa3cb0469bff5b008872644f4a5ef6d Mon Sep 17 00:00:00 2001
From: Bekiboo <julien.connault@gmail.com>
Date: Fri, 25 Sep 2026 16:10:53 +0300
Subject: [PATCH 4/5] fix(eid-wallet): give the ePassport request sheet the
 same way out
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The consent prompt exists twice. On the home screen the × deleted the request;
on ePassport there was no × at all and the backdrop is inert, so the sheet
could only be left by accepting or declining. Both now close without
answering, and the dismissed ids moved into the shared module so closing on
one surface doesn't leave the other still asking.

The ePassport decline also swallowed a failed deletion and resumed polling as
if the request were gone. It now keeps the request on screen with the error,
matching the drawer.
---
 .../src/lib/utils/pendingSocialRequest.ts     | 15 +++++
 .../src/routes/(app)/ePassport/+page.svelte   | 59 +++++++++++++------
 .../src/routes/(app)/main/+page.svelte        |  9 +--
 3 files changed, 62 insertions(+), 21 deletions(-)

diff --git a/infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts b/infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts
index 24b8c50e7..c68b35854 100644
--- a/infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts
+++ b/infrastructure/eid-wallet/src/lib/utils/pendingSocialRequest.ts
@@ -3,6 +3,21 @@ import {
     fetchUnsignedSocialDocs,
 } from "./socialBinding";
 
+/**
+ * Requests the user closed without answering, for this app session. Shared
+ * because the home screen and the ePassport sheet both prompt for the same
+ * documents, so closing one must not leave the other still asking.
+ */
+const dismissedDocIds = new Set<string>();
+
+export function dismissSocialRequest(docId: string): void {
+    dismissedDocIds.add(docId);
+}
+
+export function dismissedSocialRequests(): ReadonlySet<string> {
+    return dismissedDocIds;
+}
+
 export interface PendingSocialRequest {
     docId: string;
     parsed: BindingDocParsed;
diff --git a/infrastructure/eid-wallet/src/routes/(app)/ePassport/+page.svelte b/infrastructure/eid-wallet/src/routes/(app)/ePassport/+page.svelte
index 215199b45..1df335bfd 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/ePassport/+page.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/ePassport/+page.svelte
@@ -14,6 +14,7 @@ import {
     acceptSocialBinding,
     capitalize,
     declineSocialBinding,
+    dismissSocialRequest,
     fetchNameFromVault,
     fetchUnsignedSocialDocs,
     identityFieldLabel,
@@ -555,38 +556,50 @@ async function confirmSocialBindingRequest() {
 async function declineSocialBindingRequest() {
     const docId = socialBindingPendingDocId;
     const declinedDoc = socialBindingPendingDocParsed;
-    socialBindingAwaitingConsent = false;
-    socialBindingPendingDocId = null;
-    socialBindingPendingDocParsed = null;
-    socialBindingSignerName = null;
-    socialBindingSignerEname = null;
 
     if (docId) {
         try {
             const vault = await globalState.vaultController.vault;
-            if (vault?.ename && vault?.uri) {
-                const callerEname = vault.ename.startsWith("@")
-                    ? vault.ename
-                    : `@${vault.ename}`;
-                const gqlUrl = new URL("/graphql", vault.uri).toString();
-                await declineSocialBinding(
-                    gqlUrl,
-                    callerEname,
-                    docId,
-                    declinedDoc,
-                );
+            if (!vault?.ename || !vault?.uri) {
+                throw new Error(m.social_drawer_no_vault());
             }
+            const callerEname = vault.ename.startsWith("@")
+                ? vault.ename
+                : `@${vault.ename}`;
+            const gqlUrl = new URL("/graphql", vault.uri).toString();
+            await declineSocialBinding(gqlUrl, callerEname, docId, declinedDoc);
         } catch (err) {
+            // The document is still in the vault, so keep the request on
+            // screen instead of resuming as if it had been declined.
             console.error(
                 "[Social Binding] failed to delete declined doc:",
                 err,
             );
+            socialBindingError =
+                err instanceof Error
+                    ? err.message
+                    : m.social_drawer_error_generic();
+            return;
         }
     }
 
+    socialBindingAwaitingConsent = false;
+    socialBindingPendingDocId = null;
+    socialBindingPendingDocParsed = null;
+    socialBindingSignerName = null;
+    socialBindingSignerEname = null;
     startSocialBindingPolling();
 }
 
+// Closing without answering leaves the request in the vault. Record it so the
+// home screen doesn't prompt for the same one on the way back.
+function dismissSocialBindingRequest() {
+    if (socialBindingPendingDocId) {
+        dismissSocialRequest(socialBindingPendingDocId);
+    }
+    closeSocialBindingDrawer();
+}
+
 function startSocialBindingPolling() {
     socialBindingPolling = true;
     socialBindingPollInterval = setInterval(() => {
@@ -710,7 +723,19 @@ onMount(async () => {
             </div>
         {:else if socialBindingAwaitingConsent}
             <div>
-                <h4 class="mb-1">{m.social_drawer_request_title()}</h4>
+                <div class="flex items-start justify-between gap-3">
+                    <h4 class="mb-1">{m.social_drawer_request_title()}</h4>
+                    <button
+                        type="button"
+                        onclick={dismissSocialBindingRequest}
+                        aria-label={m.common_close()}
+                        class="w-9 h-9 rounded-full bg-black-50 flex items-center justify-center text-black-700 active:opacity-70 shrink-0"
+                    >
+                        <span aria-hidden="true" class="text-xl leading-none"
+                            >×</span
+                        >
+                    </button>
+                </div>
                 <p class="text-black-700">
                     <strong
                         >{socialBindingSignerName ??
diff --git a/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte b/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
index 80e4fee9b..42f582950 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/main/+page.svelte
@@ -27,7 +27,6 @@ let hasEverLoaded = false;
 // Requests the user closed without answering. Module-scope so leaving /main and
 // coming back doesn't prompt for them again; an app restart clears them, and
 // they stay answerable from the bindings list either way.
-const dismissedSocialRequestIds = new Set<string>();
 </script>
 
 <script lang="ts">
@@ -50,6 +49,8 @@ import {
     type PendingSocialRequest,
     fetchNameFromVault,
     fetchReconciledSocialBindings,
+    dismissSocialRequest,
+    dismissedSocialRequests,
     findPendingSocialRequest,
     resolveVaultUri,
 } from "$lib/utils";
@@ -562,7 +563,7 @@ async function checkPendingSocialRequest(): Promise<void> {
         const request = await findPendingSocialRequest(
             gqlUrl,
             callerEname,
-            dismissedSocialRequestIds,
+            dismissedSocialRequests(),
         );
         // Re-checked after the round trip: the user may have opened something
         // else while it was in flight.
@@ -575,7 +576,7 @@ async function checkPendingSocialRequest(): Promise<void> {
 }
 
 function handleSocialRequestDismissed(docId: string) {
-    dismissedSocialRequestIds.add(docId);
+    dismissSocialRequest(docId);
 }
 
 // The sheet's own poll can miss a request that lands just before the user
@@ -1249,7 +1250,7 @@ async function refreshBindings(): Promise<void> {
     bind:isOpen={socialDrawerOpen}
     {globalState}
     request={pendingSocialRequest}
-    dismissedIds={dismissedSocialRequestIds}
+    dismissedIds={dismissedSocialRequests()}
     onbound={handleSocialBound}
     ondismiss={handleSocialRequestDismissed}
 />

From 2236b55a5027d19a93ebc4ec9f66ee93feef13ab Mon Sep 17 00:00:00 2001
From: Bekiboo <julien.connault@gmail.com>
Date: Fri, 25 Sep 2026 16:35:50 +0300
Subject: [PATCH 5/5] fix(eid-wallet): let the user out of a request that will
 not delete
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A failed decline keeps the request and moves to the error phase, but the close
effect only recorded a dismissal from awaiting-consent. Closing the error
sheet left the request undismissed, so /main's close check found it again and
reopened the prompt at once — no way out while the vault delete kept failing.
A failed accept behaved the same.

Also closes the describe block that the rebase onto main left open, where both
branches had appended tests to the same file.
---
 .../eid-wallet/src/lib/utils/socialBinding.spec.ts         | 2 ++
 .../(app)/main/components/SocialBindingDrawer.svelte       | 7 ++++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts b/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts
index 19c66dd86..f6c3e6420 100644
--- a/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts
+++ b/infrastructure/eid-wallet/src/lib/utils/socialBinding.spec.ts
@@ -486,6 +486,8 @@ describe("resolveVaultUri", () => {
         await expect(resolveVaultUri("@nobody")).rejects.toThrow(
             ENAME_NOT_FOUND,
         );
+    });
+});
 
 describe("choosing the request to prompt for", () => {
     beforeEach(() => {
diff --git a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
index d9573a2bd..41a3b4a3a 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/main/components/SocialBindingDrawer.svelte
@@ -230,7 +230,12 @@ $effect(() => {
         stopPolling();
         // Closing on a request leaves it pending rather than declining it;
         // tell the parent so its poll doesn't prompt for the same one again.
-        if (phase === "awaiting-consent" && pendingDocId) {
+        // The error phase counts: a decline or accept that keeps failing would
+        // otherwise reopen the prompt on every close, with no way out.
+        if (
+            pendingDocId &&
+            (phase === "awaiting-consent" || phase === "error")
+        ) {
             ondismiss?.(pendingDocId);
         }
         reset();