Feat/eid wallet v1 (#972)

* fix: recovery flow

* fix: prevent recovery back

* fix: security question thing

* fix: security question attmept migration

* fix: UI and settings

* feat: loading sheet

* feat: new notary mechanism

* feat: enotary jwt

* fix: enotary cors issue on JWKs

* fix: notary scan and scan drawer

* chore: bump android version

Author: coodos

infrastructure/eid-wallet/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eid-wallet",
-    "version": "0.7.1",
+    "version": "1.0.0",
     "description": "",
     "type": "module",
     "scripts": {

infrastructure/eid-wallet/src-tauri/gen/android/app/src/main/java/foundation/metastate/eid_wallet/MainActivity.kt

@@ -1,11 +1,22 @@
 package foundation.metastate.eid_wallet
 
 import android.os.Bundle
+import android.view.View
+import android.webkit.WebView
 import androidx.activity.enableEdgeToEdge
 
 class MainActivity : TauriActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
     enableEdgeToEdge()
     super.onCreate(savedInstanceState)
   }
+
+  // Kill the Android WebView overscroll glow/bounce. CSS
+  // `overscroll-behavior: none` doesn't reliably suppress it on all
+  // Android WebView versions because the glow is drawn natively by the
+  // OverScroller, not the renderer. Setting OVER_SCROLL_NEVER on the
+  // WebView itself stops it at the source.
+  override fun onWebViewCreate(webView: WebView) {
+    webView.overScrollMode = View.OVER_SCROLL_NEVER
+  }
 }

infrastructure/eid-wallet/src-tauri/src/lib.rs

@@ -75,6 +75,20 @@ async fn get_platform() -> Result<String, String> {
     return Ok("unknown".to_string());
 }
 
+/// Forwards a frontend log line to the Tauri host process stdout/stderr so
+/// devs can see console output in the terminal that ran `tauri dev`, without
+/// needing the WebView devtools to be attachable.
+#[tauri::command]
+fn log_to_terminal(level: String, message: String) {
+    match level.as_str() {
+        "error" => eprintln!("[FE error] {}", message),
+        "warn" => eprintln!("[FE warn]  {}", message),
+        "info" => println!("[FE info]  {}", message),
+        "debug" => println!("[FE debug] {}", message),
+        _ => println!("[FE log]   {}", message),
+    }
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
@@ -97,7 +111,8 @@ pub fn run() {
             hash,
             verify,
             get_device_id,
-            get_platform
+            get_platform,
+            log_to_terminal
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

infrastructure/eid-wallet/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "eID for W3DS",
-    "version": "0.7.1",
+    "version": "1.0.0",
     "identifier": "foundation.metastate.eid-wallet",
     "build": {
         "beforeDevCommand": "pnpm dev",
@@ -29,7 +29,7 @@
         "active": true,
         "targets": "all",
         "android": {
-            "versionCode": 25
+            "versionCode": 26
         },
         "icon": [
             "icons/32x32.png",

infrastructure/eid-wallet/src/app.css

@@ -4,6 +4,31 @@
 @import "@fontsource-variable/roboto-condensed";
 
 @layer base {
+    /* Kill the Android WebView overscroll glow/bounce when scrolling past
+     * a container's edge. Applied at the root so it cascades into every
+     * scroll container; individual elements can opt back in with
+     * `overscroll-behavior: auto` if they need pull-to-refresh later. */
+    html,
+    body {
+        overscroll-behavior: none;
+        -webkit-tap-highlight-color: transparent;
+        /* This is a native mobile app — text selection on tap-and-hold is
+         * a desktop-browser affordance that just feels broken here, and on
+         * iOS the magnifier loupe over scan buttons / PIN dots is a regular
+         * cause of misclicks. Opt back in below for inputs/textareas. */
+        user-select: none;
+        -webkit-user-select: none;
+        -webkit-touch-callout: none;
+    }
+
+    input,
+    textarea,
+    [contenteditable="true"] {
+        user-select: text;
+        -webkit-user-select: text;
+        -webkit-touch-callout: default;
+    }
+
     /* Typography */
     h1 {
         @apply text-[90px]/[1.5] text-black font-semibold;
@@ -194,3 +219,29 @@ body {
     position: relative;
     z-index: 1;
 }
+
+/* WebView passthrough for the native camera scanner.
+ *
+ * The Tauri barcode-scanner plugin opens the camera in a native overlay
+ * BEHIND the WebView. Whichever page calls scan({ windowed: true }) must
+ * make the body + its route wrappers transparent for that scan's duration
+ * so the feed can show through. Toggled on/off by code (currently /scan-qr
+ * and /recover's notary path).
+ *
+ * Lives in app.css rather than per-layout because /recover is in (public)
+ * and (app)'s style block doesn't load there. */
+body.custom-global-style {
+    background-color: transparent;
+    overflow: hidden;
+}
+body.custom-global-style [data-route-wrapper] {
+    background-color: transparent !important;
+}
+/* The notary-recovery scan opens from /recover (public group), whose page
+ * uses `<main class="bg-white …">` instead of [data-route-wrapper]. The
+ * recover <main> is nested under the root layout's slide-wrapper divs,
+ * so we need a descendant selector. Drawers/bottom-sheets use <div
+ * role="dialog"> not <main> so this won't clobber their backgrounds. */
+body.custom-global-style main {
+    background-color: transparent !important;
+}

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -6,127 +6,93 @@ import {
     verifySignature as hwVerifySignature,
 } from "@auvo/tauri-plugin-crypto-hw-api";
 import type { KeyManager } from "./types";
-import { KeyManagerError, KeyManagerErrorCodes } from "./types";
+import {
+    KeyManagerError,
+    KeyManagerErrorCodes,
+    WALLET_KEY_ALIAS,
+} from "./types";
 
 /**
- * Hardware key manager implementation using Tauri crypto hardware API
+ * Hardware-backed key manager. Uses Android Keystore / iOS Secure Enclave / TPM
+ * via the Tauri crypto-hw plugin. Errors propagate to the caller; there is no
+ * silent fallback to software at this layer.
  */
 export class HardwareKeyManager implements KeyManager {
     getType(): "hardware" | "software" {
         return "hardware";
     }
 
-    async exists(keyId: string): Promise<boolean> {
+    async exists(): Promise<boolean> {
         try {
-            return await hwExists(keyId);
+            return await hwExists(WALLET_KEY_ALIAS);
         } catch (error) {
-            console.error("Hardware key exists check failed:", error);
             throw new KeyManagerError(
-                "Failed to check if hardware key exists",
+                `Hardware key exists check failed: ${stringifyError(error)}`,
                 KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
-                keyId,
             );
         }
     }
 
-    async generate(keyId: string): Promise<string | undefined> {
+    async generate(): Promise<void> {
         try {
-            const result = await hwGenerate(keyId);
-            console.log(`Hardware key generated for ${keyId}:`, result);
-            return result;
+            await hwGenerate(WALLET_KEY_ALIAS);
         } catch (error) {
-            console.error("Hardware key generation failed:", error);
             throw new KeyManagerError(
-                "Failed to generate hardware key",
+                `Hardware key generation failed: ${stringifyError(error)}`,
                 KeyManagerErrorCodes.KEY_GENERATION_FAILED,
-                keyId,
             );
         }
     }
 
-    async getPublicKey(keyId: string): Promise<string | undefined> {
+    async getPublicKey(): Promise<string> {
         try {
-            const publicKey = await hwGetPublicKey(keyId);
-            console.log(
-                `Hardware public key retrieved for ${keyId}:`,
-                publicKey,
-            );
-            return publicKey;
+            const pk = await hwGetPublicKey(WALLET_KEY_ALIAS);
+            if (!pk) {
+                throw new KeyManagerError(
+                    "Hardware key not found",
+                    KeyManagerErrorCodes.KEY_NOT_FOUND,
+                );
+            }
+            return pk;
         } catch (error) {
-            console.error("Hardware public key retrieval failed:", error);
+            if (error instanceof KeyManagerError) throw error;
             throw new KeyManagerError(
-                "Failed to get hardware public key",
+                `Hardware public key retrieval failed: ${stringifyError(error)}`,
                 KeyManagerErrorCodes.KEY_NOT_FOUND,
-                keyId,
             );
         }
     }
 
-    async signPayload(keyId: string, payload: string): Promise<string> {
+    async signPayload(payload: string): Promise<string> {
         try {
-            console.log("=".repeat(70));
-            console.log("🔐 [HardwareKeyManager] signPayload called");
-            console.log("=".repeat(70));
-            console.log(`Key ID: ${keyId}`);
-            console.log(`Payload: "${payload}"`);
-            console.log(`Payload length: ${payload.length} bytes`);
-            const payloadHex = Array.from(new TextEncoder().encode(payload))
-                .map((b) => b.toString(16).padStart(2, "0"))
-                .join("");
-            console.log(`Payload (hex): ${payloadHex}`);
-
-            // Get and log the public key
-            try {
-                const publicKey = await this.getPublicKey(keyId);
-                if (publicKey) {
-                    console.log(`Public key: ${publicKey.substring(0, 60)}...`);
-                    console.log(`Public key (full): ${publicKey}`);
-                } else {
-                    console.log("⚠️  Public key not available");
-                }
-            } catch (error) {
-                console.log(
-                    `⚠️  Failed to get public key: ${error instanceof Error ? error.message : String(error)}`,
-                );
-            }
-
-            console.log("Signing with hardware key...");
-            const signature = await hwSignPayload(keyId, payload);
-            console.log(`✅ Hardware signature created for ${keyId}`);
-            console.log(`Signature: ${signature.substring(0, 50)}...`);
-            console.log(`Signature (full): ${signature}`);
-            console.log(`Signature length: ${signature.length} chars`);
-            console.log("=".repeat(70));
-            return signature;
+            return await hwSignPayload(WALLET_KEY_ALIAS, payload);
         } catch (error) {
-            console.error("❌ Hardware signing failed:", error);
             throw new KeyManagerError(
-                "Failed to sign payload with hardware key",
+                `Hardware signing failed: ${stringifyError(error)}`,
                 KeyManagerErrorCodes.SIGNING_FAILED,
-                keyId,
             );
         }
     }
 
     async verifySignature(
-        keyId: string,
         payload: string,
         signature: string,
     ): Promise<boolean> {
         try {
-            const isValid = await hwVerifySignature(keyId, payload, signature);
-            console.log(
-                `Hardware signature verification for ${keyId}:`,
-                isValid,
+            return await hwVerifySignature(
+                WALLET_KEY_ALIAS,
+                payload,
+                signature,
             );
-            return isValid;
         } catch (error) {
-            console.error("Hardware signature verification failed:", error);
             throw new KeyManagerError(
-                "Failed to verify signature with hardware key",
+                `Hardware signature verification failed: ${stringifyError(error)}`,
                 KeyManagerErrorCodes.VERIFICATION_FAILED,
-                keyId,
             );
         }
     }
 }
+
+function stringifyError(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}