diff --git a/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/baselineProfiles/0/app-arm64-release.dm b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/baselineProfiles/0/app-arm64-release.dm
new file mode 100644
index 00000000..31d9873c
Binary files /dev/null and b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/baselineProfiles/0/app-arm64-release.dm differ
diff --git a/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/baselineProfiles/1/app-arm64-release.dm b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/baselineProfiles/1/app-arm64-release.dm
new file mode 100644
index 00000000..a437c2ee
Binary files /dev/null and b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/baselineProfiles/1/app-arm64-release.dm differ
diff --git a/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/eid-w3ds-v0.2.1.0.apk b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/eid-w3ds-v0.2.1.0.apk
new file mode 100644
index 00000000..2e334d32
Binary files /dev/null and b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/eid-w3ds-v0.2.1.0.apk differ
diff --git a/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/output-metadata.json b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/output-metadata.json
new file mode 100644
index 00000000..625869fa
--- /dev/null
+++ b/infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/output-metadata.json
@@ -0,0 +1,37 @@
+{
+  "version": 3,
+  "artifactType": {
+    "type": "APK",
+    "kind": "Directory"
+  },
+  "applicationId": "foundation.metastate.eid_wallet",
+  "variantName": "arm64Release",
+  "elements": [
+    {
+      "type": "SINGLE",
+      "filters": [],
+      "attributes": [],
+      "versionCode": 2,
+      "versionName": "0.1.8",
+      "outputFile": "app-arm64-release.apk"
+    }
+  ],
+  "elementType": "File",
+  "baselineProfiles": [
+    {
+      "minApi": 28,
+      "maxApi": 30,
+      "baselineProfiles": [
+        "baselineProfiles/1/app-arm64-release.dm"
+      ]
+    },
+    {
+      "minApi": 31,
+      "maxApi": 2147483647,
+      "baselineProfiles": [
+        "baselineProfiles/0/app-arm64-release.dm"
+      ]
+    }
+  ],
+  "minSdkVersionForDexing": 24
+}
\ No newline at end of file
diff --git a/infrastructure/eid-wallet/src/routes/(app)/scan-qr/+page.svelte b/infrastructure/eid-wallet/src/routes/(app)/scan-qr/+page.svelte
index a7e18281..e4f24ddc 100644
--- a/infrastructure/eid-wallet/src/routes/(app)/scan-qr/+page.svelte
+++ b/infrastructure/eid-wallet/src/routes/(app)/scan-qr/+page.svelte
@@ -374,13 +374,14 @@
                     "🔍 DEBUG: Is poll request?",
                     !!(signingData?.pollId && signingData?.voteData),
                 );
+
+                // Only set signing modal for regular signing requests (not blind voting)
+                isSigningRequest = true;
+                signingDrawerOpen = true;
             } catch (error) {
                 console.error("Error decoding signing data:", error);
                 return;
             }
-
-            isSigningRequest = true;
-            signingDrawerOpen = true;
         } catch (error) {
             console.error("Error parsing signing request:", error);
         }
@@ -597,6 +598,15 @@
             blindVoteError = null; // Clear any previous errors
 
             console.log("✅ Blind voting request set up successfully");
+            console.log("🔍 DEBUG: State after setup:");
+            console.log("  - isBlindVotingRequest:", isBlindVotingRequest);
+            console.log("  - signingDrawerOpen:", signingDrawerOpen);
+            console.log("  - signingData:", signingData);
+            console.log("  - signingData.pollId:", signingData?.pollId);
+            console.log(
+                "  - signingData.pollDetails:",
+                !!signingData?.pollDetails,
+            );
         } catch (error) {
             console.error("❌ Error handling blind voting request:", error);
         }
@@ -953,7 +963,7 @@
         console.log("Scan QR page mounted, checking for deep link data...");
 
         // Function to handle deep link data
-        function handleDeepLinkData(data: any) {
+        async function handleDeepLinkData(data: any) {
             console.log("Handling deep link data:", data);
             console.log("Data type:", data.type);
             console.log("Platform:", data.platform);
@@ -999,24 +1009,91 @@
                         const decodedString = atob(base64Data);
                         signingData = JSON.parse(decodedString);
                         console.log("Decoded signing data:", signingData);
+
+                        // Check if this is actually a blind voting request
+                        if (signingData.type === "blind-vote") {
+                            console.log(
+                                "🔍 Blind voting request detected in sign deep link",
+                            );
+
+                            // Set up blind voting state
+                            isBlindVotingRequest = true;
+                            selectedBlindVoteOption = null;
+                            signingDrawerOpen = true;
+                            blindVoteError = null;
+
+                            // Extract platform URL from the data
+                            const platformUrl =
+                                signingData.platformUrl ||
+                                "http://192.168.0.225:7777";
+
+                            // Set up signingData for blind voting UI
+                            signingData = {
+                                pollId: signingData.pollId,
+                                sessionId: signingData.sessionId,
+                                platform_url: platformUrl,
+                                redirect: redirectUri, // Add the redirect URI from the deep link
+                                // We'll need to fetch poll details, but for now set a placeholder
+                                pollDetails: {
+                                    title: "Loading poll details...",
+                                    creatorName: "Loading...",
+                                    options: ["Loading..."],
+                                },
+                            };
+
+                            // Fetch poll details in the background
+                            try {
+                                const pollResponse = await fetch(
+                                    `${platformUrl}/api/polls/${signingData.pollId}`,
+                                );
+                                if (pollResponse.ok) {
+                                    const pollDetails =
+                                        await pollResponse.json();
+                                    signingData.pollDetails = pollDetails;
+                                    console.log(
+                                        "✅ Poll details fetched:",
+                                        pollDetails,
+                                    );
+                                }
+                            } catch (error) {
+                                console.error(
+                                    "Failed to fetch poll details:",
+                                    error,
+                                );
+                                blindVoteError = "Failed to load poll details";
+                            }
+
+                            return;
+                        }
+
+                        // Regular signing request
+                        isSigningRequest = true;
+                        signingDrawerOpen = true;
+                        console.log("Signing modal should now be open");
                     } catch (error) {
                         console.error("Error decoding signing data:", error);
                         return;
                     }
-                    isSigningRequest = true;
-                    signingDrawerOpen = true;
-                    console.log("Signing modal should now be open");
                 }
-            }
-            // Handle blind voting requests
-            if (data.type === "blind-vote") {
-                console.log("🔍 Blind voting request detected");
-                isBlindVotingRequest = true;
-                selectedBlindVoteOption = null;
-                signingData = data;
-                signingDrawerOpen = true;
-                blindVoteError = null; // Clear any previous errors
-                return;
+            } else if (data.type === "reveal") {
+                console.log("Handling reveal deep link");
+                // Handle reveal deep link
+                const pollId = data.pollId;
+
+                if (pollId) {
+                    console.log("🔍 Reveal request for poll:", pollId);
+
+                    // Set up reveal state
+                    revealPollId = pollId;
+                    isRevealRequest = true;
+
+                    console.log("✅ Reveal request set up successfully");
+                    console.log("🔍 DEBUG: State after setup:");
+                    console.log("  - revealPollId:", revealPollId);
+                    console.log("  - isRevealRequest:", isRevealRequest);
+                } else {
+                    console.error("Missing pollId in reveal request");
+                }
             }
         }
 
@@ -1032,7 +1109,7 @@
             try {
                 const data = JSON.parse(deepLinkData);
                 console.log("Parsed deep link data:", data);
-                handleDeepLinkData(data);
+                await handleDeepLinkData(data);
                 // Clear both storage keys to be safe
                 sessionStorage.removeItem("deepLinkData");
                 sessionStorage.removeItem("pendingDeepLink");
@@ -1048,40 +1125,36 @@
         }
 
         // Listen for deep link events when already on the page
-        const handleAuthEvent = (event: CustomEvent) => {
+        const handleAuthEvent = async (event: CustomEvent) => {
             console.log("Received deepLinkAuth event:", event.detail);
-            handleDeepLinkData({
+            await handleDeepLinkData({
                 type: "auth",
                 ...event.detail,
             });
         };
 
-        const handleSignEvent = (event: CustomEvent) => {
+        const handleSignEvent = async (event: CustomEvent) => {
             console.log("Received deepLinkSign event:", event.detail);
-            handleDeepLinkData({
+            await handleDeepLinkData({
                 type: "sign",
                 ...event.detail,
             });
         };
 
-        window.addEventListener(
-            "deepLinkAuth",
-            handleAuthEvent as EventListener,
+        window.addEventListener("deepLinkAuth", (event) =>
+            handleAuthEvent(event as CustomEvent),
         );
-        window.addEventListener(
-            "deepLinkSign",
-            handleSignEvent as EventListener,
+        window.addEventListener("deepLinkSign", (event) =>
+            handleSignEvent(event as CustomEvent),
         );
 
         // Cleanup event listeners
         onDestroy(() => {
-            window.removeEventListener(
-                "deepLinkAuth",
-                handleAuthEvent as EventListener,
+            window.removeEventListener("deepLinkAuth", (event) =>
+                handleAuthEvent(event as CustomEvent),
             );
-            window.removeEventListener(
-                "deepLinkSign",
-                handleSignEvent as EventListener,
+            window.removeEventListener("deepLinkSign", (event) =>
+                handleSignEvent(event as CustomEvent),
             );
         });
     });
diff --git a/infrastructure/eid-wallet/src/routes/+layout.svelte b/infrastructure/eid-wallet/src/routes/+layout.svelte
index 80fdfc5b..f60c1526 100644
--- a/infrastructure/eid-wallet/src/routes/+layout.svelte
+++ b/infrastructure/eid-wallet/src/routes/+layout.svelte
@@ -1,298 +1,360 @@
 <script lang="ts">
-import SplashScreen from "$lib/fragments/SplashScreen/SplashScreen.svelte";
-import { onMount, setContext, getContext } from "svelte";
-import "../app.css";
-import { onNavigate, goto } from "$app/navigation";
-import { GlobalState } from "$lib/global/state";
-
-import { runtime } from "$lib/global/runtime.svelte";
-import { type Status, checkStatus } from "@tauri-apps/plugin-biometric";
-
-const { children } = $props();
-
-let globalState: GlobalState | undefined = $state(undefined);
-
-let showSplashScreen = $state(false);
-let previousRoute = null;
-let navigationStack: string[] = [];
-
-setContext("globalState", () => globalState);
-
-// replace with actual data loading logic
-async function loadData() {
-    await new Promise((resolve) => setTimeout(resolve, 1500));
-}
-
-async function ensureMinimumDelay() {
-    await new Promise((resolve) => setTimeout(resolve, 500));
-}
-
-onMount(async () => {
-    let status: Status | undefined = undefined;
-    try {
-        status = await checkStatus();
-    } catch (error) {
-        status = {
-            biometryType: 0,
-            isAvailable: false,
-        };
-    }
-    runtime.biometry = status.biometryType;
-    try {
-        globalState = await GlobalState.create();
-    } catch (error) {
-        console.error("Failed to initialize global state:", error);
-        // Consider adding fallback behavior or user notification
-    }
+    import SplashScreen from "$lib/fragments/SplashScreen/SplashScreen.svelte";
+    import { onMount, setContext, getContext } from "svelte";
+    import "../app.css";
+    import { onNavigate, goto } from "$app/navigation";
+    import { GlobalState } from "$lib/global/state";
 
-    // Handle deep links
-    try {
-        const { onOpenUrl, getCurrent } = await import(
-            "@tauri-apps/plugin-deep-link"
-        );
+    import { runtime } from "$lib/global/runtime.svelte";
+    import { type Status, checkStatus } from "@tauri-apps/plugin-biometric";
 
-        // Check if app was started via deep link
-        const initialUrls = await getCurrent();
-        if (initialUrls && initialUrls.length > 0) {
-            handleDeepLink(initialUrls[0]);
-        }
+    const { children } = $props();
 
-        // Listen for future deep links
-        await onOpenUrl((urls) => {
-            if (urls && urls.length > 0) {
-                handleDeepLink(urls[0]);
-            }
-        });
-    } catch (error) {
-        console.error("Failed to initialize deep link listener:", error);
+    let globalState: GlobalState | undefined = $state(undefined);
+
+    let showSplashScreen = $state(false);
+    let previousRoute = null;
+    let navigationStack: string[] = [];
+
+    setContext("globalState", () => globalState);
+
+    // replace with actual data loading logic
+    async function loadData() {
+        await new Promise((resolve) => setTimeout(resolve, 1500));
     }
 
-    function handleDeepLink(urlString: string) {
-        console.log("Deep link received:", urlString);
+    async function ensureMinimumDelay() {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+
+    onMount(async () => {
+        let status: Status | undefined = undefined;
         try {
-            const url = new URL(urlString);
-            const path = url.pathname;
-            const params = url.searchParams;
-
-            console.log("Deep link path:", path);
-            console.log("Deep link hostname:", url.hostname);
-            console.log("Deep link protocol:", url.protocol);
-            console.log("Deep link full URL object:", url);
-            console.log(
-                "Deep link params:",
-                Object.fromEntries(params.entries()),
-            );
+            status = await checkStatus();
+        } catch (error) {
+            status = {
+                biometryType: 0,
+                isAvailable: false,
+            };
+        }
+        runtime.biometry = status.biometryType;
+        try {
+            globalState = await GlobalState.create();
+        } catch (error) {
+            console.error("Failed to initialize global state:", error);
+            // Consider adding fallback behavior or user notification
+        }
 
-            // Check if we're already on the scan-qr page
-            const currentPath = window.location.pathname;
-            const isOnScanPage = currentPath === "/scan-qr";
-            console.log(
-                "Current path:",
-                currentPath,
-                "Is on scan page:",
-                isOnScanPage,
+        // Handle deep links
+        try {
+            const { onOpenUrl, getCurrent } = await import(
+                "@tauri-apps/plugin-deep-link"
             );
 
-            // For w3ds:// URLs, we need to check the hostname instead of pathname
-            // w3ds://auth becomes hostname: "auth", pathname: ""
-            const action = url.hostname || path;
-            console.log("Deep link action (hostname):", action);
+            // Check if app was started via deep link
+            const initialUrls = await getCurrent();
+            if (initialUrls && initialUrls.length > 0) {
+                handleDeepLink(initialUrls[0]);
+            }
+
+            // Listen for future deep links
+            await onOpenUrl((urls) => {
+                if (urls && urls.length > 0) {
+                    handleDeepLink(urls[0]);
+                }
+            });
+        } catch (error) {
+            console.error("Failed to initialize deep link listener:", error);
+        }
 
-            // Example: w3ds://auth?session=123&platform=example&redirect=https://example.com
-            if (action === "auth") {
-                // Handle authentication deep link
-                const sessionId = params.get("session");
-                const platform = params.get("platform");
-                const redirect = params.get("redirect");
+        function handleDeepLink(urlString: string) {
+            console.log("Deep link received:", urlString);
+            try {
+                const url = new URL(urlString);
+                const path = url.pathname;
+                const params = url.searchParams;
+
+                console.log("Deep link path:", path);
+                console.log("Deep link hostname:", url.hostname);
+                console.log("Deep link protocol:", url.protocol);
+                console.log("Deep link full URL object:", url);
+                console.log(
+                    "Deep link params:",
+                    Object.fromEntries(params.entries()),
+                );
 
+                // Check if we're already on the scan-qr page
+                const currentPath = window.location.pathname;
+                const isOnScanPage = currentPath === "/scan-qr";
                 console.log(
-                    "Auth deep link - session:",
-                    sessionId,
-                    "platform:",
-                    platform,
-                    "redirect:",
-                    redirect,
+                    "Current path:",
+                    currentPath,
+                    "Is on scan page:",
+                    isOnScanPage,
                 );
 
-                if (sessionId && platform && redirect) {
-                    // Always store the deep link data first
-                    const deepLinkData = {
-                        type: "auth",
-                        session: sessionId,
-                        platform: platform,
-                        redirect: redirect,
-                    };
-
-                    // Check if user is authenticated by looking for vault data
-                    const checkAuth = async () => {
-                        try {
-                            // Try to access vault data - if this fails, user is not authenticated
-                            const globalState =
-                                getContext<() => GlobalState>("globalState")();
-                            if (globalState) {
-                                const vault =
-                                    await globalState.vaultController.vault;
-                                if (vault) {
-                                    // User is authenticated, go to scan page
-                                    console.log(
-                                        "User authenticated, navigating to scan-qr",
-                                    );
-                                    sessionStorage.setItem(
-                                        "deepLinkData",
-                                        JSON.stringify(deepLinkData),
-                                    );
-                                    goto("/scan-qr");
-                                    return;
+                // For w3ds:// URLs, we need to check the hostname instead of pathname
+                // w3ds://auth becomes hostname: "auth", pathname: ""
+                const action = url.hostname || path;
+                console.log("Deep link action (hostname):", action);
+
+                // Example: w3ds://auth?session=123&platform=example&redirect=https://example.com
+                if (action === "auth") {
+                    // Handle authentication deep link
+                    const sessionId = params.get("session");
+                    const platform = params.get("platform");
+                    const redirect = params.get("redirect");
+
+                    console.log(
+                        "Auth deep link - session:",
+                        sessionId,
+                        "platform:",
+                        platform,
+                        "redirect:",
+                        redirect,
+                    );
+
+                    if (sessionId && platform && redirect) {
+                        // Always store the deep link data first
+                        const deepLinkData = {
+                            type: "auth",
+                            session: sessionId,
+                            platform: platform,
+                            redirect: redirect,
+                        };
+
+                        // Check if user is authenticated by looking for vault data
+                        const checkAuth = async () => {
+                            try {
+                                // Try to access vault data - if this fails, user is not authenticated
+                                const globalState =
+                                    getContext<() => GlobalState>(
+                                        "globalState",
+                                    )();
+                                if (globalState) {
+                                    const vault =
+                                        await globalState.vaultController.vault;
+                                    if (vault) {
+                                        // User is authenticated, go to scan page
+                                        console.log(
+                                            "User authenticated, navigating to scan-qr",
+                                        );
+                                        sessionStorage.setItem(
+                                            "deepLinkData",
+                                            JSON.stringify(deepLinkData),
+                                        );
+                                        goto("/scan-qr");
+                                        return;
+                                    }
                                 }
+                            } catch (error) {
+                                console.log(
+                                    "User not authenticated, redirecting to login",
+                                );
                             }
-                        } catch (error) {
+
+                            // User not authenticated, store deep link data and redirect to login
                             console.log(
-                                "User not authenticated, redirecting to login",
+                                "User not authenticated, storing deep link data and redirecting to login",
                             );
-                        }
-
-                        // User not authenticated, store deep link data and redirect to login
-                        console.log(
-                            "User not authenticated, storing deep link data and redirecting to login",
-                        );
-                        sessionStorage.setItem(
-                            "pendingDeepLink",
-                            JSON.stringify(deepLinkData),
-                        );
-                        goto("/login");
-                    };
-
-                    checkAuth();
-                } else {
-                    console.log("Missing required auth parameters");
-                }
-            } else if (action === "sign") {
-                // Handle signing deep link
-                const sessionId = params.get("session");
-                const data = params.get("data");
-                const redirectUri = params.get("redirect_uri");
-
-                console.log(
-                    "Sign deep link - session:",
-                    sessionId,
-                    "data:",
-                    data,
-                    "redirect_uri:",
-                    redirectUri,
-                );
+                            sessionStorage.setItem(
+                                "pendingDeepLink",
+                                JSON.stringify(deepLinkData),
+                            );
+                            goto("/login");
+                        };
+
+                        checkAuth();
+                    } else {
+                        console.log("Missing required auth parameters");
+                    }
+                } else if (action === "sign") {
+                    // Handle signing deep link
+                    const sessionId = params.get("session");
+                    const data = params.get("data");
+                    const redirectUri = params.get("redirect_uri");
+
+                    console.log(
+                        "Sign deep link - session:",
+                        sessionId,
+                        "data:",
+                        data,
+                        "redirect_uri:",
+                        redirectUri,
+                    );
+
+                    if (sessionId && data && redirectUri) {
+                        // Always store the deep link data first
+                        const deepLinkData = {
+                            type: "sign",
+                            session: sessionId,
+                            data: data,
+                            redirect_uri: redirectUri,
+                        };
+
+                        // Check if user is authenticated by looking for vault data
+                        const checkAuth = async () => {
+                            try {
+                                // Try to access vault data - if this fails, user is not authenticated
+                                const globalState =
+                                    getContext<() => GlobalState>(
+                                        "globalState",
+                                    )();
+                                if (globalState) {
+                                    const vault =
+                                        await globalState.vaultController.vault;
+                                    if (vault) {
+                                        // User is authenticated, go to scan page
+                                        console.log(
+                                            "User authenticated, navigating to scan-qr",
+                                        );
+                                        sessionStorage.setItem(
+                                            "deepLinkData",
+                                            JSON.stringify(deepLinkData),
+                                        );
+                                        goto("/scan-qr");
+                                        return;
+                                    }
+                                }
+                            } catch (error) {
+                                console.log(
+                                    "User not authenticated, redirecting to login",
+                                );
+                            }
 
-                if (sessionId && data && redirectUri) {
-                    // Always store the deep link data first
-                    const deepLinkData = {
-                        type: "sign",
-                        session: sessionId,
-                        data: data,
-                        redirect_uri: redirectUri,
-                    };
-
-                    // Check if user is authenticated by looking for vault data
-                    const checkAuth = async () => {
-                        try {
-                            // Try to access vault data - if this fails, user is not authenticated
-                            const globalState =
-                                getContext<() => GlobalState>("globalState")();
-                            if (globalState) {
-                                const vault =
-                                    await globalState.vaultController.vault;
-                                if (vault) {
-                                    // User is authenticated, go to scan page
-                                    console.log(
-                                        "User authenticated, navigating to scan-qr",
-                                    );
-                                    sessionStorage.setItem(
-                                        "deepLinkData",
-                                        JSON.stringify(deepLinkData),
-                                    );
-                                    goto("/scan-qr");
-                                    return;
+                            // User not authenticated, store deep link data and redirect to login
+                            console.log(
+                                "User not authenticated, storing deep link data and redirecting to login",
+                            );
+                            sessionStorage.setItem(
+                                "pendingDeepLink",
+                                JSON.stringify(deepLinkData),
+                            );
+                            goto("/login");
+                        };
+
+                        checkAuth();
+                    } else {
+                        console.log("Missing required signing parameters");
+                    }
+                } else if (action === "reveal") {
+                    // Handle reveal deep link
+                    const pollId = params.get("pollId");
+
+                    console.log("Reveal deep link - pollId:", pollId);
+
+                    if (pollId) {
+                        // Always store the deep link data first
+                        const deepLinkData = {
+                            type: "reveal",
+                            pollId: pollId,
+                        };
+
+                        // Check if user is authenticated by looking for vault data
+                        const checkAuth = async () => {
+                            try {
+                                // Try to access vault data - if this fails, user is not authenticated
+                                const globalState =
+                                    getContext<() => GlobalState>(
+                                        "globalState",
+                                    )();
+                                if (globalState) {
+                                    const vault =
+                                        await globalState.vaultController.vault;
+                                    if (vault) {
+                                        // User is authenticated, go to scan page
+                                        console.log(
+                                            "User authenticated, navigating to scan-qr for reveal",
+                                        );
+                                        sessionStorage.setItem(
+                                            "deepLinkData",
+                                            JSON.stringify(deepLinkData),
+                                        );
+                                        goto("/scan-qr");
+                                        return;
+                                    }
                                 }
+                            } catch (error) {
+                                console.log(
+                                    "User not authenticated, redirecting to login",
+                                );
                             }
-                        } catch (error) {
+
+                            // User not authenticated, store deep link data and redirect to login
                             console.log(
-                                "User not authenticated, redirecting to login",
+                                "User not authenticated, storing reveal deep link data and redirecting to login",
+                            );
+                            sessionStorage.setItem(
+                                "pendingDeepLink",
+                                JSON.stringify(deepLinkData),
                             );
-                        }
-
-                        // User not authenticated, store deep link data and redirect to login
-                        console.log(
-                            "User not authenticated, storing deep link data and redirecting to login",
-                        );
-                        sessionStorage.setItem(
-                            "pendingDeepLink",
-                            JSON.stringify(deepLinkData),
-                        );
-                        goto("/login");
-                    };
-
-                    checkAuth();
+                            goto("/login");
+                        };
+
+                        checkAuth();
+                    } else {
+                        console.log("Missing required reveal parameters");
+                    }
                 } else {
-                    console.log("Missing required signing parameters");
+                    console.log("Unknown deep link path:", path);
                 }
-            } else {
-                console.log("Unknown deep link path:", path);
+            } catch (error) {
+                console.error("Failed to parse deep link URL:", error);
             }
-        } catch (error) {
-            console.error("Failed to parse deep link URL:", error);
         }
-    }
 
-    showSplashScreen = true; // Can't set up the original state to true or animation won't start
-    navigationStack.push(window.location.pathname);
+        showSplashScreen = true; // Can't set up the original state to true or animation won't start
+        navigationStack.push(window.location.pathname);
 
-    await Promise.all([loadData(), ensureMinimumDelay()]);
+        await Promise.all([loadData(), ensureMinimumDelay()]);
 
-    showSplashScreen = false;
-});
+        showSplashScreen = false;
+    });
 
-const safeAreaTop = $derived.by(
-    () =>
-        Number.parseFloat(
-            getComputedStyle(document.documentElement).getPropertyValue(
-                "--safe-top",
-            ),
-        ) || 0,
-);
+    const safeAreaTop = $derived.by(
+        () =>
+            Number.parseFloat(
+                getComputedStyle(document.documentElement).getPropertyValue(
+                    "--safe-top",
+                ),
+            ) || 0,
+    );
 
-$effect(() => console.log("top", safeAreaTop));
+    $effect(() => console.log("top", safeAreaTop));
 
-onNavigate((navigation) => {
-    if (!document.startViewTransition) return;
+    onNavigate((navigation) => {
+        if (!document.startViewTransition) return;
 
-    const from = navigation.from?.url.pathname;
-    const to = navigation.to?.url.pathname;
+        const from = navigation.from?.url.pathname;
+        const to = navigation.to?.url.pathname;
 
-    if (!from || !to || from === to) return;
+        if (!from || !to || from === to) return;
 
-    let direction: "left" | "right" = "right";
+        let direction: "left" | "right" = "right";
 
-    const fromIndex = navigationStack.lastIndexOf(from);
-    const toIndex = navigationStack.lastIndexOf(to);
+        const fromIndex = navigationStack.lastIndexOf(from);
+        const toIndex = navigationStack.lastIndexOf(to);
 
-    if (toIndex !== -1 && toIndex < fromIndex) {
-        // Backward navigation
-        direction = "left";
-        navigationStack = navigationStack.slice(0, toIndex + 1);
-    } else {
-        // Forward navigation (or new path)
-        direction = "right";
-        navigationStack.push(to);
-    }
+        if (toIndex !== -1 && toIndex < fromIndex) {
+            // Backward navigation
+            direction = "left";
+            navigationStack = navigationStack.slice(0, toIndex + 1);
+        } else {
+            // Forward navigation (or new path)
+            direction = "right";
+            navigationStack.push(to);
+        }
 
-    document.documentElement.setAttribute("data-transition", direction);
-    previousRoute = to;
+        document.documentElement.setAttribute("data-transition", direction);
+        previousRoute = to;
 
-    return new Promise((resolve) => {
-        document.startViewTransition(async () => {
-            resolve();
-            await navigation.complete;
+        return new Promise((resolve) => {
+            document.startViewTransition(async () => {
+                resolve();
+                await navigation.complete;
+            });
         });
     });
-});
 </script>
 
 {#if showSplashScreen}
diff --git a/platforms/eVoting/src/app/(app)/layout.tsx b/platforms/eVoting/src/app/(app)/layout.tsx
index 2b0c898f..eaaf9d04 100644
--- a/platforms/eVoting/src/app/(app)/layout.tsx
+++ b/platforms/eVoting/src/app/(app)/layout.tsx
@@ -14,6 +14,13 @@ import {
 } from "@/components/ui/dialog";
 import { ProtectedRoute } from "@/components/auth/protected-route";
 
+// Deeplink handling for reveal functionality
+declare global {
+    interface WindowEventMap {
+        deepLinkReveal: CustomEvent<{ pollId: string }>;
+    }
+}
+
 export default function AppLayout({
     children,
 }: Readonly<{
@@ -21,6 +28,29 @@ export default function AppLayout({
 }>) {
     const { logout } = useAuth();
     const [disclaimerAccepted, setDisclaimerAccepted] = useState(false);
+    const router = useRouter();
+
+    // Handle deeplink reveal requests
+    useEffect(() => {
+        const handleDeepLinkReveal = (event: CustomEvent<{ pollId: string }>) => {
+            console.log("🔍 Deep link reveal request received:", event.detail);
+            const { pollId } = event.detail;
+            
+            // Navigate to the poll page to show reveal interface
+            router.push(`/${pollId}`);
+            
+            // Store the reveal request in sessionStorage for the poll page to pick up
+            sessionStorage.setItem("revealRequest", JSON.stringify({ pollId, timestamp: Date.now() }));
+        };
+
+        // Listen for deeplink reveal events
+        window.addEventListener("deepLinkReveal", handleDeepLinkReveal as EventListener);
+
+        // Cleanup
+        return () => {
+            window.removeEventListener("deepLinkReveal", handleDeepLinkReveal as EventListener);
+        };
+    }, [router]);
 
     return (
         <ProtectedRoute>
diff --git a/platforms/eVoting/src/components/blind-voting-interface.tsx b/platforms/eVoting/src/components/blind-voting-interface.tsx
index 0f3e1814..075cecef 100644
--- a/platforms/eVoting/src/components/blind-voting-interface.tsx
+++ b/platforms/eVoting/src/components/blind-voting-interface.tsx
@@ -4,6 +4,7 @@ import { Vote, UserX, Shield, CheckCircle } from 'lucide-react';
 import { Button } from "@/components/ui/button";
 import { useToast } from "@/hooks/use-toast";
 import type { Poll } from "@/lib/pollApi";
+import { createRevealDeepLink } from "@/lib/utils/mobile-detection";
 
 interface BlindVotingInterfaceProps {
   poll: Poll;
@@ -19,8 +20,29 @@ export default function BlindVotingInterface({ poll, userId, hasVoted, onVoteSub
   const [error, setError] = useState<string>('');
   const [voteStatus, setVoteStatus] = useState<{ hasVoted: boolean; vote: any } | null>(null);
   const [isConnected, setIsConnected] = useState(false);
+  const [showRevealInterface, setShowRevealInterface] = useState(false);
+  const [revealRequest, setRevealRequest] = useState<any>(null);
   const { toast } = useToast();
 
+  // Check for reveal requests from deeplinks
+  useEffect(() => {
+    const storedRevealRequest = sessionStorage.getItem("revealRequest");
+    if (storedRevealRequest) {
+      try {
+        const request = JSON.parse(storedRevealRequest);
+        if (request.pollId === poll.id) {
+          console.log("🔍 Reveal request detected for this poll:", request);
+          setRevealRequest(request);
+          setShowRevealInterface(true);
+          // Clear the stored request
+          sessionStorage.removeItem("revealRequest");
+        }
+      } catch (error) {
+        console.error("Error parsing reveal request:", error);
+      }
+    }
+  }, [poll.id]);
+
   // SSE connection for real-time vote status updates
   useEffect(() => {
     if (!poll.id || !userId) return;
@@ -135,6 +157,47 @@ export default function BlindVotingInterface({ poll, userId, hasVoted, onVoteSub
     pollId: poll.id
   });
 
+  // Show reveal interface if requested via deeplink
+  if (showRevealInterface) {
+    return (
+      <div className="space-y-6">
+        <div className="text-center py-8">
+          <Shield className="text-blue-500 h-16 w-16 mx-auto mb-4" />
+          <h3 className="text-xl font-semibold text-gray-900 mb-2">Reveal Your Vote</h3>
+          <p className="text-gray-600">Use your eID wallet to reveal your vote choice</p>
+        </div>
+
+        <div className="bg-blue-50 border border-blue-200 rounded-lg p-6">
+          <div className="text-center mb-4">
+            <h4 className="text-lg font-semibold text-blue-900">Reveal Request</h4>
+            <p className="text-blue-700 text-sm">
+              A reveal request was detected for this poll. Please use your eID wallet to reveal your vote.
+            </p>
+          </div>
+
+          <div className="text-center space-y-4">
+            <p className="text-sm text-blue-600">
+              Poll ID: {poll.id}
+            </p>
+            <p className="text-xs text-blue-500">
+              Reveal request received at: {revealRequest?.timestamp ? new Date(revealRequest.timestamp).toLocaleString() : 'Unknown'}
+            </p>
+          </div>
+
+          <div className="mt-4 p-3 bg-white rounded-lg border border-blue-200">
+            <h5 className="font-medium text-blue-900 mb-2">Next Steps:</h5>
+            <ol className="text-sm text-blue-700 space-y-1 list-decimal list-inside">
+              <li>Open your eID wallet</li>
+              <li>Navigate to the reveal section</li>
+              <li>Select this poll to reveal your vote</li>
+              <li>Your vote choice will be displayed locally</li>
+            </ol>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
   if (currentHasVoted) {
     return (
       <div className="space-y-6">
@@ -151,41 +214,60 @@ export default function BlindVotingInterface({ poll, userId, hasVoted, onVoteSub
             <Shield className="text-blue-600 h-8 w-8 mx-auto mb-2" />
             <h4 className="text-lg font-semibold text-blue-900">Reveal Your Vote</h4>
             <p className="text-blue-700 text-sm">
-              Use this QR code to reveal your vote choice when you're ready
+              Use this to reveal your vote choice when you're ready
             </p>
           </div>
 
-          {/* Reveal QR Code */}
+          {/* Responsive Reveal Section */}
           <div className="text-center space-y-4">
-            <div className="inline-block">
-              <QRCodeSVG
-                value={`w3ds://reveal?pollId=${poll.id}`}
+            {/* Mobile: Show button, Desktop: Show QR */}
+            <div className="block md:hidden">
+              <Button
+                onClick={() => {
+                  // Create the reveal deeplink using utility function
+                  const revealLink = createRevealDeepLink(poll.id);
+                  console.log("🔍 Opening reveal deeplink:", revealLink);
+                  window.open(revealLink, '_blank');
+                }}
+                className="w-full btn-primary bg-blue-600 hover:bg-blue-700"
+              >
+                <Shield className="w-4 h-4 mr-2" />
+                Reveal Vote in eID Wallet
+              </Button>
+            </div>
+            
+            {/* Desktop: Show QR code */}
+            <div className="hidden md:block">
+              <div className="inline-block">
+                              <QRCodeSVG
+                value={createRevealDeepLink(poll.id)}
                 size={150}
                 level="M"
                 includeMargin={true}
               />
-            </div>
-            
-            <div className="space-y-2">
-              <p className="text-sm text-blue-600">
-                Scan this QR code with your eID wallet to reveal your vote
-              </p>
-              <p className="text-xs text-blue-500">
-                Poll ID: {poll.id}
-              </p>
+              </div>
+              
+              <div className="space-y-2">
+                <p className="text-sm text-blue-600">
+                  Scan this QR code with your eID wallet to reveal your vote
+                </p>
+                <p className="text-xs text-blue-500">
+                  Poll ID: {poll.id}
+                </p>
+              </div>
             </div>
           </div>
 
-                      {/* Instructions */}
-            <div className="mt-4 p-3 bg-white rounded-lg border border-blue-200">
-                <h5 className="font-medium text-blue-900 mb-2">How to Reveal:</h5>
-                <ol className="text-sm text-blue-700 space-y-1 list-decimal list-inside">
-                    <li>Scan the reveal QR code with your eID wallet</li>
-                    <li>Confirm your identity in the wallet</li>
-                    <li>Your vote choice will be revealed locally</li>
-                    <li>Your vote remains completely private and anonymous</li>
-                </ol>
-            </div>
+          {/* Instructions */}
+          <div className="mt-4 p-3 bg-white rounded-lg border border-blue-200">
+            <h5 className="font-medium text-blue-900 mb-2">How to Reveal:</h5>
+            <ol className="text-sm text-blue-700 space-y-1 list-decimal list-inside">
+              <li>Use the button/QR code to open your eID wallet</li>
+              <li>Confirm your identity in the wallet</li>
+              <li>Your vote choice will be revealed locally</li>
+              <li>Your vote remains completely private and anonymous</li>
+            </ol>
+          </div>
         </div>
       </div>
     );
diff --git a/platforms/eVoting/src/lib/utils/mobile-detection.ts b/platforms/eVoting/src/lib/utils/mobile-detection.ts
index d381195b..d3d0ed0e 100644
--- a/platforms/eVoting/src/lib/utils/mobile-detection.ts
+++ b/platforms/eVoting/src/lib/utils/mobile-detection.ts
@@ -7,4 +7,8 @@ export function isMobileDevice(): boolean {
 
 export function getDeepLinkUrl(qrData: string): string {
   return qrData;
+}
+
+export function createRevealDeepLink(pollId: string): string {
+  return `w3ds://reveal?pollId=${pollId}`;
 } 
\ No newline at end of file