decane-connect-kit 1.0.3 → 2.0.1

package/dist/index.js

@@ -1,3 +1,155 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/social/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AttestationError: () => AttestationError,
+  CallSequenceError: () => CallSequenceError,
+  DecaneConnectError: () => DecaneConnectError,
+  ExportNotAuthorizedError: () => ExportNotAuthorizedError,
+  InvalidApiKeyError: () => InvalidApiKeyError,
+  InvalidPinError: () => InvalidPinError,
+  InvalidRecoveryFileError: () => InvalidRecoveryFileError,
+  NetworkError: () => NetworkError,
+  NewDeviceError: () => NewDeviceError,
+  OriginNotAllowedError: () => OriginNotAllowedError,
+  PromptPinNotConfiguredError: () => PromptPinNotConfiguredError,
+  ReconnectRequiredError: () => ReconnectRequiredError,
+  RecoveryFailedError: () => RecoveryFailedError,
+  RecoveryWalletMismatchError: () => RecoveryWalletMismatchError,
+  SessionExpiredError: () => SessionExpiredError,
+  ShareCorruptedError: () => ShareCorruptedError,
+  UnlockRequiredError: () => UnlockRequiredError,
+  UserCancelledError: () => UserCancelledError,
+  WebAuthnNotSupportedError: () => WebAuthnNotSupportedError,
+  WrongPasswordError: () => WrongPasswordError
+});
+var DecaneConnectError, InvalidApiKeyError, OriginNotAllowedError, SessionExpiredError, UnlockRequiredError, ReconnectRequiredError, UserCancelledError, WebAuthnNotSupportedError, InvalidPinError, CallSequenceError, NetworkError, ShareCorruptedError, NewDeviceError, PromptPinNotConfiguredError, AttestationError, RecoveryFailedError, InvalidRecoveryFileError, WrongPasswordError, RecoveryWalletMismatchError, ExportNotAuthorizedError;
+var init_errors = __esm({
+  "src/social/errors.ts"() {
+    "use strict";
+    DecaneConnectError = class extends Error {
+      constructor(code, message, retryable = false) {
+        super(message);
+        this.name = "DecaneConnectError";
+        this.code = code;
+        this.retryable = retryable;
+      }
+    };
+    InvalidApiKeyError = class extends DecaneConnectError {
+      constructor() {
+        super("INVALID_API_KEY", "API key is invalid or revoked");
+      }
+    };
+    OriginNotAllowedError = class extends DecaneConnectError {
+      constructor(origin) {
+        super("ORIGIN_NOT_ALLOWED", `Origin ${origin} not in API key allowlist`);
+      }
+    };
+    SessionExpiredError = class extends DecaneConnectError {
+      constructor() {
+        super("SESSION_EXPIRED", "Session has expired \u2014 call unlock()", true);
+      }
+    };
+    UnlockRequiredError = class extends DecaneConnectError {
+      constructor() {
+        super("UNLOCK_REQUIRED", "Wallet must be unlocked before signing", true);
+      }
+    };
+    ReconnectRequiredError = class extends DecaneConnectError {
+      constructor() {
+        super(
+          "RECONNECT_REQUIRED",
+          "Your session ended \u2014 sign in again to unlock this wallet",
+          true
+        );
+      }
+    };
+    UserCancelledError = class extends DecaneConnectError {
+      constructor() {
+        super("USER_CANCELLED", "User cancelled the operation", true);
+      }
+    };
+    WebAuthnNotSupportedError = class extends DecaneConnectError {
+      constructor() {
+        super("WEBAUTHN_UNSUPPORTED", "This browser does not support WebAuthn");
+      }
+    };
+    InvalidPinError = class extends DecaneConnectError {
+      constructor() {
+        super("INVALID_PIN", "Incorrect PIN", true);
+      }
+    };
+    CallSequenceError = class extends DecaneConnectError {
+      constructor(msg) {
+        super("CALL_SEQUENCE", msg);
+      }
+    };
+    NetworkError = class extends DecaneConnectError {
+      constructor() {
+        super("NETWORK", "Network request failed", true);
+      }
+    };
+    ShareCorruptedError = class extends DecaneConnectError {
+      constructor() {
+        super("SHARE_CORRUPTED", "Stored device share is corrupted");
+      }
+    };
+    NewDeviceError = class extends DecaneConnectError {
+      constructor() {
+        super("NEW_DEVICE", "No device share found. Re-authenticate to set up this device.");
+      }
+    };
+    PromptPinNotConfiguredError = class extends DecaneConnectError {
+      constructor() {
+        super("PROMPT_PIN_NOT_CONFIGURED", "Passkey unavailable and no promptPin callback was provided in config");
+      }
+    };
+    AttestationError = class extends DecaneConnectError {
+      constructor(msg) {
+        super("ATTESTATION_FAILED", msg);
+      }
+    };
+    RecoveryFailedError = class extends DecaneConnectError {
+      constructor(reason) {
+        super("RECOVERY_FAILED", `Recovery failed: ${reason}`, true);
+      }
+    };
+    InvalidRecoveryFileError = class extends DecaneConnectError {
+      constructor() {
+        super("INVALID_RECOVERY_FILE", "This does not look like a valid recovery file", false);
+      }
+    };
+    WrongPasswordError = class extends DecaneConnectError {
+      constructor() {
+        super("WRONG_PASSWORD", "Incorrect password for this recovery file", true);
+      }
+    };
+    RecoveryWalletMismatchError = class extends DecaneConnectError {
+      constructor() {
+        super(
+          "RECOVERY_WALLET_MISMATCH",
+          "This recovery file is for a different wallet than the account you are signed into",
+          false
+        );
+      }
+    };
+    ExportNotAuthorizedError = class extends DecaneConnectError {
+      constructor() {
+        super("EXPORT_NOT_AUTHORIZED", "Export requires a fresh security check", true);
+      }
+    };
+  }
+});
+
 // src/core/emitter.ts
 function createEmitter() {
   const listeners = /* @__PURE__ */ new Map();
@@ -1734,94 +1886,10 @@ function createDecane(config = {}) {
 }
 
 // src/social/client.ts
+init_errors();
 import { Wallet } from "ethers";
 import { Transaction as Transaction2, VersionedTransaction, Keypair } from "@solana/web3.js";
 
-// src/social/errors.ts
-var DecaneConnectError = class extends Error {
-  constructor(code, message, retryable = false) {
-    super(message);
-    this.name = "DecaneConnectError";
-    this.code = code;
-    this.retryable = retryable;
-  }
-};
-var InvalidApiKeyError = class extends DecaneConnectError {
-  constructor() {
-    super("INVALID_API_KEY", "API key is invalid or revoked");
-  }
-};
-var OriginNotAllowedError = class extends DecaneConnectError {
-  constructor(origin) {
-    super("ORIGIN_NOT_ALLOWED", `Origin ${origin} not in API key allowlist`);
-  }
-};
-var SessionExpiredError = class extends DecaneConnectError {
-  constructor() {
-    super("SESSION_EXPIRED", "Session has expired \u2014 call unlock()", true);
-  }
-};
-var UnlockRequiredError = class extends DecaneConnectError {
-  constructor() {
-    super("UNLOCK_REQUIRED", "Wallet must be unlocked before signing", true);
-  }
-};
-var UserCancelledError = class extends DecaneConnectError {
-  constructor() {
-    super("USER_CANCELLED", "User cancelled the operation", true);
-  }
-};
-var WebAuthnNotSupportedError = class extends DecaneConnectError {
-  constructor() {
-    super("WEBAUTHN_UNSUPPORTED", "This browser does not support WebAuthn");
-  }
-};
-var InvalidPinError = class extends DecaneConnectError {
-  constructor() {
-    super("INVALID_PIN", "Incorrect PIN", true);
-  }
-};
-var CallSequenceError = class extends DecaneConnectError {
-  constructor(msg) {
-    super("CALL_SEQUENCE", msg);
-  }
-};
-var NetworkError = class extends DecaneConnectError {
-  constructor() {
-    super("NETWORK", "Network request failed", true);
-  }
-};
-var ShareCorruptedError = class extends DecaneConnectError {
-  constructor() {
-    super("SHARE_CORRUPTED", "Stored device share is corrupted");
-  }
-};
-var NewDeviceError = class extends DecaneConnectError {
-  constructor() {
-    super("NEW_DEVICE", "No device share found. Re-authenticate to set up this device.");
-  }
-};
-var PromptPinNotConfiguredError = class extends DecaneConnectError {
-  constructor() {
-    super("PROMPT_PIN_NOT_CONFIGURED", "Passkey unavailable and no promptPin callback was provided in config");
-  }
-};
-var AttestationError = class extends DecaneConnectError {
-  constructor(msg) {
-    super("ATTESTATION_FAILED", msg);
-  }
-};
-var RecoveryFailedError = class extends DecaneConnectError {
-  constructor(reason) {
-    super("RECOVERY_FAILED", `Recovery failed: ${reason}`, true);
-  }
-};
-var InvalidPhraseError = class extends DecaneConnectError {
-  constructor() {
-    super("INVALID_PHRASE", "Recovery phrase is invalid or corrupted", true);
-  }
-};
-
 // src/social/events.ts
 var EventEmitter = class {
   constructor() {
@@ -1840,6 +1908,7 @@ var EventEmitter = class {
 };
 
 // src/social/api.ts
+init_errors();
 var ERROR_MAP = {
   INVALID_API_KEY: InvalidApiKeyError,
   ORIGIN_NOT_ALLOWED: OriginNotAllowedError
@@ -1910,13 +1979,26 @@ var ApiClient = class {
       })
     });
   }
+  // ── WebAuthn registration (additive to the PRF-only passkey flow) ─────────
+  async getWebAuthnRegisterOptions(jwt, rpId, rpName) {
+    return this._request(`/webauthn/register-options?rpId=${encodeURIComponent(rpId)}&rpName=${encodeURIComponent(rpName)}`, {
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+  }
+  async postWebAuthnRegister(jwt, response, origin) {
+    await this._request("/webauthn/register", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` },
+      body: JSON.stringify({ response, origin })
+    });
+  }
   async revoke(jwt) {
     await this._request("/auth/revoke", {
       method: "POST",
       headers: { Authorization: `Bearer ${jwt}` }
     });
   }
-  // ── Recovery (passkey-sync backup + phrase-saved flag) ────────────────────
+  // ── Recovery (passkey-sync backup + recovery-share-saved flag) ────────────
   async hasRecoveryBackup(jwt) {
     const data = await this._request("/recovery/backup/exists", {
       headers: { Authorization: `Bearer ${jwt}` }
@@ -1957,8 +2039,19 @@ var ApiClient = class {
       headers: { Authorization: `Bearer ${jwt}` }
     });
   }
-  async markPhraseSaved(jwt) {
-    await this._request("/recovery/phrase-saved", {
+  async markRecoveryShareSaved(jwt) {
+    await this._request("/recovery/share-saved", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+  }
+  async getRecoveryStatus(jwt) {
+    return this._request("/recovery/status", {
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+  }
+  async dismissRecoveryNag(jwt) {
+    await this._request("/recovery/nag-dismissed", {
       method: "POST",
       headers: { Authorization: `Bearer ${jwt}` }
     });
@@ -1967,8 +2060,8 @@ var ApiClient = class {
 function bytesToB64(bytes) {
   return btoa(String.fromCharCode(...bytes));
 }
-function b64ToBytes(b642) {
-  return Uint8Array.from(atob(b642), (c) => c.charCodeAt(0));
+function b64ToBytes(b644) {
+  return Uint8Array.from(atob(b644), (c) => c.charCodeAt(0));
 }
 
 // src/social/storage.ts
@@ -1994,7 +2087,11 @@ var Storage = class {
   }
 };
 
+// src/social/teeClient.ts
+import { startAuthentication } from "@simplewebauthn/browser";
+
 // src/social/attestation.ts
+init_errors();
 import { getCollateralAndVerify } from "@phala/dcap-qvl";
 
 // ../../infra/tee-measurement.json
@@ -2053,11 +2150,15 @@ async function verifyTeeAttestation(teeUrl, nonce) {
 }
 
 // src/social/teeClient.ts
+init_errors();
 function bytesToBase64(b) {
   let s = "";
   for (const byte of b) s += String.fromCharCode(byte);
   return btoa(s);
 }
+function base64ToBytes(s) {
+  return Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
+}
 var TeeClient = class {
   constructor(teeUrl) {
     this.teeUrl = teeUrl;
@@ -2071,6 +2172,13 @@ var TeeClient = class {
     await verifyTeeAttestation(this.teeUrl, nonceHex);
     this.attested = true;
   }
+  /**
+   * Opens a signing session and returns the addresses the TEE derived from the
+   * key it actually reconstructed — authoritative, unlike the backend's
+   * recorded copy, which nothing else can verify. Returns null if the TEE
+   * couldn't derive them (older signer build, or a transient share-fetch
+   * failure); callers fall back to the backend's addresses in that case.
+   */
   async openSession(deviceShare, jwt) {
     await this.ensureAttested();
     const res = await fetch(`${this.teeUrl}/signer/session`, {
@@ -2079,18 +2187,94 @@ var TeeClient = class {
       body: JSON.stringify({ deviceShare: bytesToBase64(deviceShare) })
     });
     if (!res.ok) throw new Error("session open failed");
-    this.handle = (await res.json()).handle;
+    const body = await res.json();
+    this.handle = body.handle;
+    return body.addresses ?? null;
   }
-  /** Verify a candidate device share (from a recovery phrase) without exposing shares. */
-  async verifyRecoveryCandidate(deviceShare, jwt) {
+  /**
+   * Flow B: exchange a recovery share (from a recovery-share file) for a
+   * fresh device share. The server verifies the reconstructed master
+   * actually matches this account's addresses before returning anything —
+   * see the security note in the TEE's /signer/recover handler. Rotates the
+   * whole share set: the caller MUST persist the returned recoveryShare as a
+   * new recovery-share file, since the old one stops working immediately.
+   */
+  async recoverWithShare(jwt, recoveryShare) {
     await this.ensureAttested();
-    const res = await fetch(`${this.teeUrl}/signer/verify-recovery`, {
+    const res = await fetch(`${this.teeUrl}/signer/recover`, {
       method: "POST",
       headers: { Authorization: `Bearer ${jwt}`, "Content-Type": "application/json" },
-      body: JSON.stringify({ deviceShare: bytesToBase64(deviceShare) })
+      body: JSON.stringify({ recoveryShare: bytesToBase64(recoveryShare) })
+    });
+    if (res.status === 403) {
+      const { RecoveryWalletMismatchError: RecoveryWalletMismatchError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      throw new RecoveryWalletMismatchError2();
+    }
+    if (!res.ok) throw new Error("recovery failed");
+    const body = await res.json();
+    return {
+      deviceShare: base64ToBytes(body.deviceShare),
+      recoveryShare: base64ToBytes(body.recoveryShare),
+      shareSetVersion: body.shareSetVersion
+    };
+  }
+  /**
+   * Request a fresh WebAuthn assertion challenge and complete it in the
+   * browser via @simplewebauthn/browser's startAuthentication(), which
+   * handles all the base64url (de)serialization the raw navigator.credentials
+   * API requires. Shared by rotateShares() and exportPortableBackup() — both
+   * require proof of fresh authenticator possession, not just an active session.
+   */
+  async completeAssertion(jwt) {
+    const res = await fetch(`${this.teeUrl}/signer/assertion-challenge`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ rpId: window.location.hostname })
     });
-    if (!res.ok) return false;
-    return (await res.json()).verified === true;
+    if (!res.ok) throw new ExportNotAuthorizedError();
+    const { challengeId, options } = await res.json();
+    let assertion;
+    try {
+      assertion = await startAuthentication({ optionsJSON: options });
+    } catch {
+      const { UserCancelledError: UserCancelledError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      throw new UserCancelledError2();
+    }
+    return { challengeId, assertion };
+  }
+  /** Voluntary rotation — e.g. after a suspected device compromise, or to invalidate an old recovery file. */
+  async rotateShares(jwt) {
+    if (!this.handle) throw new Error("no session");
+    const { challengeId, assertion } = await this.completeAssertion(jwt);
+    const res = await fetch(`${this.teeUrl}/signer/rotate`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ handle: this.handle, challengeId, assertion, origin: window.location.origin })
+    });
+    if (!res.ok) throw new ExportNotAuthorizedError();
+    const body = await res.json();
+    return {
+      deviceShare: base64ToBytes(body.deviceShare),
+      recoveryShare: base64ToBytes(body.recoveryShare),
+      shareSetVersion: body.shareSetVersion
+    };
+  }
+  /** The two-share bearer portable backup — see recovery/portableBackup.ts. Rotates the set on export. */
+  async exportPortableBackup(jwt) {
+    if (!this.handle) throw new Error("no session");
+    const { challengeId, assertion } = await this.completeAssertion(jwt);
+    const res = await fetch(`${this.teeUrl}/signer/export-portable`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ handle: this.handle, challengeId, assertion, origin: window.location.origin })
+    });
+    if (!res.ok) throw new ExportNotAuthorizedError();
+    const body = await res.json();
+    return {
+      deviceShare: base64ToBytes(body.deviceShare),
+      recoveryShare: base64ToBytes(body.recoveryShare),
+      shareSetVersion: body.shareSetVersion
+    };
   }
   hasSession() {
     return this.handle !== null;
@@ -2123,6 +2307,7 @@ var TeeClient = class {
 };
 
 // src/social/session.ts
+init_errors();
 var SessionManager = class {
   constructor(events, durationMs, teeUrl) {
     this.events = events;
@@ -2137,9 +2322,24 @@ var SessionManager = class {
       window.addEventListener("pagehide", () => this.end());
     }
   }
-  async start(deviceShare, jwt, addresses) {
+  /**
+   * Opens the TEE session and resolves which addresses this wallet really has.
+   *
+   * `fallback` is whatever the backend recorded; the TEE's answer is derived
+   * from the signing key itself and therefore outranks it. Returns the
+   * resolved addresses so callers can propagate the corrected values rather
+   * than continuing to use a stale record.
+   */
+  async start(deviceShare, jwt, fallback) {
     this.tee = new TeeClient(this.teeUrl);
-    await this.tee.openSession(deviceShare, jwt);
+    const verified = await this.tee.openSession(deviceShare, jwt);
+    const addresses = verified ?? fallback;
+    if (!addresses) {
+      this.tee = null;
+      throw new Error(
+        "No addresses available for this wallet \u2014 the signer could not derive them and none are recorded"
+      );
+    }
     this.evmAddress = addresses.evm;
     this.solanaAddress = addresses.solana;
     this.expiresAt = Date.now() + this.durationMs;
@@ -2149,6 +2349,7 @@ var SessionManager = class {
       this.events.emit("session-expired");
     }, this.durationMs);
     this.events.emit("session-started");
+    return addresses;
   }
   end() {
     void this.tee?.closeSession();
@@ -2178,24 +2379,32 @@ var SessionManager = class {
 };
 
 // src/social/crypto/shares.ts
-function xorBytes(a, b) {
-  if (a.length !== b.length) throw new Error("xorBytes: length mismatch");
-  const out = new Uint8Array(a.length);
-  for (let i = 0; i < a.length; i++) out[i] = a[i] ^ b[i];
-  return out;
-}
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { split, combine } from "shamir-secret-sharing";
 function generateRandomBytes(n) {
   return crypto.getRandomValues(new Uint8Array(n));
 }
-function generateWalletShares() {
-  const privateKey = generateRandomBytes(32);
-  const deviceShare = generateRandomBytes(32);
-  const serverShare = xorBytes(privateKey, deviceShare);
-  return { privateKey, deviceShare, serverShare };
-}
 function zeroize(bytes) {
   bytes.fill(0);
 }
+function generateMaster() {
+  let master;
+  do {
+    master = generateRandomBytes(32);
+  } while (!secp256k1.utils.isValidPrivateKey(master));
+  return master;
+}
+async function splitMaster(master, version = 1) {
+  if (master.length !== 32) throw new Error("master must be 32 bytes");
+  const parts = await split(master, 3, 2);
+  if (parts.length !== 3) throw new Error("unexpected share count");
+  return { device: parts[0], server: parts[1], recovery: parts[2], version };
+}
+async function combineShares(a, b) {
+  const master = await combine([a, b]);
+  if (master.length !== 32) throw new Error("reconstruction produced wrong length");
+  return master;
+}
 
 // src/social/crypto/wrap.ts
 function buf(u) {
@@ -2240,6 +2449,8 @@ function validatePin(pin) {
 }
 
 // src/social/crypto/passkey.ts
+init_errors();
+import { startRegistration } from "@simplewebauthn/browser";
 function buf3(u) {
   return u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
 }
@@ -2247,30 +2458,24 @@ function isPasskeySupported() {
   return typeof window !== "undefined" && !!window.PublicKeyCredential && "isUserVerifyingPlatformAuthenticatorAvailable" in window.PublicKeyCredential;
 }
 async function registerPasskey(opts) {
-  const challenge = crypto.getRandomValues(new Uint8Array(32));
-  let cred;
+  let response;
   try {
-    cred = await navigator.credentials.create({
-      publicKey: {
-        challenge: buf3(challenge),
-        rp: { id: opts.rpId, name: opts.rpName },
-        user: { id: buf3(opts.userId), name: opts.userName, displayName: opts.userName },
-        pubKeyCredParams: [
-          { type: "public-key", alg: -7 },
-          { type: "public-key", alg: -257 }
-        ],
-        authenticatorSelection: { userVerification: "required", residentKey: "preferred" },
-        extensions: { prf: { eval: { first: buf3(opts.prfSalt) } } }
-      }
-    });
+    response = await startRegistration({ optionsJSON: opts.optionsJSON });
   } catch (e) {
     if (e.name === "NotAllowedError") throw new UserCancelledError();
     throw e;
   }
-  const ext = cred.getClientExtensionResults();
-  const prfResults = ext?.prf?.results;
-  const prfOutput = prfResults?.first ? new Uint8Array(prfResults.first) : void 0;
-  return { credentialId: new Uint8Array(cred.rawId), prfOutput };
+  const extResults = response.clientExtensionResults;
+  const prfResults = extResults?.prf?.results;
+  let prfOutput;
+  if (prfResults?.first) {
+    prfOutput = typeof prfResults.first === "string" ? Uint8Array.from(atob(prfResults.first.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0)) : new Uint8Array(prfResults.first);
+  }
+  const credentialId = Uint8Array.from(
+    atob(response.id.replace(/-/g, "+").replace(/_/g, "/")),
+    (c) => c.charCodeAt(0)
+  );
+  return { credentialId, prfOutput, response };
 }
 async function getPrfOutput(opts) {
   const challenge = crypto.getRandomValues(new Uint8Array(32));
@@ -2295,6 +2500,28 @@ async function getPrfOutput(opts) {
   return new Uint8Array(prfResults.first);
 }
 
+// src/social/webauthnRegistration.ts
+function bufFromBytes(u) {
+  return u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
+}
+async function registerWebAuthnCredential(opts) {
+  const baseOptions = await opts.api.getWebAuthnRegisterOptions(opts.jwt, opts.rpId, opts.rpName);
+  const optionsJSON = {
+    ...baseOptions,
+    extensions: {
+      ...baseOptions.extensions,
+      prf: { eval: { first: bufFromBytes(opts.prfSalt) } }
+    }
+  };
+  const { credentialId, prfOutput, response } = await registerPasskey({ optionsJSON });
+  try {
+    await opts.api.postWebAuthnRegister(opts.jwt, response, window.location.origin);
+  } catch (e) {
+    console.warn("decane-connect-kit: WebAuthn server-side registration failed; PRF-based unlock still works, but rotateShares()/exportPortableBackup() will not until this is retried.", e);
+  }
+  return { credentialId, prfOutput };
+}
+
 // src/social/auth/email.ts
 async function startEmailAuth(api, email) {
   await api.authEmailStart(email);
@@ -2341,28 +2568,102 @@ async function fetchWrappedShareBackup(api, jwt) {
   return api.getRecoveryBackup(jwt);
 }
 
-// src/social/recovery/phrase.ts
-import { entropyToMnemonic, mnemonicToEntropy, validateMnemonic } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-function shareToPhrase(deviceShare) {
-  if (deviceShare.length !== 32) throw new Error("deviceShare must be 32 bytes");
-  return entropyToMnemonic(deviceShare, wordlist);
+// src/social/recovery/recoveryShareFile.ts
+init_errors();
+var PBKDF2_ITERATIONS2 = 6e5;
+var FILE_VERSION = 2;
+function b642(u) {
+  let s = "";
+  for (const b of u) s += String.fromCharCode(b);
+  return btoa(s);
 }
-function phraseToShare(phrase) {
-  const normalized = phrase.trim().toLowerCase().split(/\s+/).join(" ");
-  if (!validateMnemonic(normalized, wordlist)) throw new InvalidPhraseError();
-  const entropy = mnemonicToEntropy(normalized, wordlist);
-  if (entropy.length !== 32) throw new InvalidPhraseError();
-  return entropy;
+function unb642(s) {
+  return Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
 }
-function phraseConfirmationChallenge(phrase) {
-  const words = phrase.trim().split(/\s+/);
-  const chosen = /* @__PURE__ */ new Set();
-  while (chosen.size < 3) chosen.add(Math.floor(Math.random() * words.length));
-  return [...chosen].sort((a, b) => a - b).map((i) => ({ position: i + 1, expected: words[i] }));
+function buf4(u) {
+  return u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
+}
+async function deriveFileKey(password, salt, iterations) {
+  const base = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    "PBKDF2",
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt: buf4(salt), iterations, hash: "SHA-256" },
+    base,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function buildRecoveryShareFile(share, password, addresses, shareSetVersion, passwordHint) {
+  if (share.length !== 33) throw new Error("share must be 33 bytes");
+  if (password.length < 8) throw new Error("password must be at least 8 characters");
+  if (passwordHint && passwordHint.trim() === password) {
+    throw new Error("password hint must not be the password");
+  }
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const key = await deriveFileKey(password, salt, PBKDF2_ITERATIONS2);
+  const ct = new Uint8Array(
+    await crypto.subtle.encrypt({ name: "AES-GCM", iv: buf4(iv) }, key, buf4(share))
+  );
+  return {
+    version: FILE_VERSION,
+    type: "decane-recovery-share",
+    shareSetVersion,
+    kdf: "pbkdf2-sha256",
+    kdfParams: { iterations: PBKDF2_ITERATIONS2, salt: b642(salt) },
+    cipher: "aes-256-gcm",
+    iv: b642(iv),
+    ciphertext: b642(ct),
+    addresses,
+    passwordHint: passwordHint?.trim() || null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function parseRecoveryShareFile(json) {
+  const raw = json;
+  if (raw?.type === "decane-recovery") {
+    throw new InvalidRecoveryFileError();
+  }
+  const f = json;
+  if (!f || f.type !== "decane-recovery-share" || f.version !== FILE_VERSION || f.kdf !== "pbkdf2-sha256" || f.cipher !== "aes-256-gcm" || typeof f.iv !== "string" || typeof f.ciphertext !== "string" || typeof f.kdfParams?.salt !== "string" || typeof f.kdfParams?.iterations !== "number" || typeof f.shareSetVersion !== "number" || typeof f.addresses?.evm !== "string" || typeof f.addresses?.solana !== "string") {
+    throw new InvalidRecoveryFileError();
+  }
+  if (f.kdfParams.iterations < 1e5 || f.kdfParams.iterations > 5e6) {
+    throw new InvalidRecoveryFileError();
+  }
+  return f;
+}
+async function decryptRecoveryShareFile(file, password) {
+  const salt = unb642(file.kdfParams.salt);
+  const iv = unb642(file.iv);
+  const ct = unb642(file.ciphertext);
+  const key = await deriveFileKey(password, salt, file.kdfParams.iterations);
+  let share;
+  try {
+    share = new Uint8Array(
+      await crypto.subtle.decrypt({ name: "AES-GCM", iv: buf4(iv) }, key, buf4(ct))
+    );
+  } catch {
+    throw new WrongPasswordError();
+  }
+  if (share.length !== 33) {
+    share.fill(0);
+    throw new InvalidRecoveryFileError();
+  }
+  return share;
+}
+function recoveryShareFileName(evmAddress) {
+  return `decane-recovery-${evmAddress.slice(0, 8)}.json`;
 }
 
 // src/social/recovery/recoveryFlow.ts
+init_errors();
 async function recoverDeviceShare(input) {
   const backup = await fetchWrappedShareBackup(input.api, input.jwt);
   if (backup) {
@@ -2396,37 +2697,87 @@ async function recoverDeviceShare(input) {
       });
     }
   }
-  if (!input.promptForPhrase) throw new NewDeviceError();
-  input.onProgress?.({ type: "phrase-prompt" });
-  const phrase = await input.promptForPhrase();
-  if (!phrase) throw new NewDeviceError();
-  let candidate;
-  try {
-    candidate = phraseToShare(phrase);
-  } catch {
-    throw new InvalidPhraseError();
-  }
-  input.onProgress?.({ type: "phrase-verifying" });
+  if (!input.promptForRecoveryFile) throw new NewDeviceError();
+  input.onProgress?.({ type: "recovery-file-prompt" });
+  const supplied = await input.promptForRecoveryFile();
+  if (!supplied) throw new NewDeviceError();
+  const file = parseRecoveryShareFile(supplied.value);
+  input.onProgress?.({ type: "password-prompt", passwordHint: file.passwordHint });
+  const password = await supplied.getPassword();
+  if (!password) throw new NewDeviceError();
+  const recoveryShare = await decryptRecoveryShareFile(file, password);
+  input.onProgress?.({ type: "recovery-verifying" });
   const tee = new TeeClient(input.teeUrl);
-  const verified = await tee.verifyRecoveryCandidate(candidate, input.jwt);
-  if (!verified) {
-    zeroize(candidate);
-    throw new RecoveryFailedError("phrase-mismatch");
+  let result;
+  try {
+    result = await tee.recoverWithShare(input.jwt, recoveryShare);
+  } finally {
+    zeroize(recoveryShare);
   }
-  return candidate;
+  input.onProgress?.({ type: "rotated", shareSetVersion: result.shareSetVersion });
+  await input.onNewRecoveryShare?.(result.recoveryShare, result.shareSetVersion);
+  zeroize(result.recoveryShare);
+  return result.deviceShare;
 }
 
-// src/social/recovery/phraseUi.ts
-function buildPhraseResult(deviceShare) {
-  const phrase = shareToPhrase(deviceShare);
-  return { phrase, challenge: phraseConfirmationChallenge(phrase) };
+// src/social/recovery/portableBackup.ts
+init_errors();
+var PBKDF2_ITERATIONS3 = 6e5;
+var FILE_VERSION2 = 1;
+function b643(u) {
+  let s = "";
+  for (const b of u) s += String.fromCharCode(b);
+  return btoa(s);
 }
-function verifyConfirmationChallenge(challenge, userAnswers) {
-  if (userAnswers.length !== challenge.length) return false;
-  return challenge.every(({ position, expected }) => {
-    const answer = userAnswers.find((a) => a.position === position);
-    return !!answer && answer.word.trim().toLowerCase() === expected.toLowerCase();
-  });
+function buf5(u) {
+  return u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
+}
+async function deriveFileKey2(password, salt, iterations) {
+  const base = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    "PBKDF2",
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt: buf5(salt), iterations, hash: "SHA-256" },
+    base,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function buildPortableBackup(deviceShare, recoveryShare, password, addresses, shareSetVersion, passwordHint) {
+  if (deviceShare.length !== 33 || recoveryShare.length !== 33) {
+    throw new Error("shares must be 33 bytes");
+  }
+  if (password.length < 8) throw new Error("password must be at least 8 characters");
+  if (passwordHint && passwordHint.trim() === password) {
+    throw new Error("password hint must not be the password");
+  }
+  const plaintext = new TextEncoder().encode(
+    JSON.stringify({ deviceShare: b643(deviceShare), recoveryShare: b643(recoveryShare) })
+  );
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const key = await deriveFileKey2(password, salt, PBKDF2_ITERATIONS3);
+  const ct = new Uint8Array(
+    await crypto.subtle.encrypt({ name: "AES-GCM", iv: buf5(iv) }, key, buf5(plaintext))
+  );
+  return {
+    version: FILE_VERSION2,
+    type: "decane-portable-backup",
+    shareSetVersion,
+    kdf: "pbkdf2-sha256",
+    kdfParams: { iterations: PBKDF2_ITERATIONS3, salt: b643(salt) },
+    cipher: "aes-256-gcm",
+    iv: b643(iv),
+    ciphertext: b643(ct),
+    addresses,
+    passwordHint: passwordHint?.trim() || null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
 
 // src/social/client.ts
@@ -2498,6 +2849,18 @@ async function createDecaneConnect(config) {
       }
     };
   }
+  async function persistRotatedDeviceShare(userId, deviceShare) {
+    const stored = await storage.getShare(userId);
+    if (!stored) {
+      throw new CallSequenceError(
+        "Share set was rotated but this device has no stored share to update. Recover the wallet on this device before rotating."
+      );
+    }
+    const wrappingKey = await getWrappingKey(stored);
+    const iv = generateRandomBytes(12);
+    const wrappedDeviceShare = await aesGcmEncrypt(wrappingKey, deviceShare, iv);
+    await storage.putShare({ ...stored, wrappedDeviceShare, iv });
+  }
   async function getWrappingKey(stored) {
     if (stored.unlockMethod === "passkey") {
       const prfOutput = await getPrfOutput({
@@ -2517,15 +2880,7 @@ async function createDecaneConnect(config) {
     let credentialId;
     let prfOutput;
     try {
-      const authType = config.authMethods[0] ?? "social";
-      const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const result = await registerPasskey({
-        rpId,
-        rpName,
-        userId: new TextEncoder().encode(userId),
-        userName: `decane-wallet-${authType}-${dateStr}`,
-        prfSalt
-      });
+      const result = await registerWebAuthnCredential({ api, jwt, rpId, rpName, prfSalt });
       credentialId = result.credentialId;
       prfOutput = result.prfOutput;
     } catch (e) {
@@ -2564,15 +2919,7 @@ async function createDecaneConnect(config) {
     if (isPasskeySupported()) {
       const prfSalt = generateRandomBytes(32);
       try {
-        const authType = config.authMethods[0] ?? "social";
-        const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-        const { credentialId, prfOutput } = await registerPasskey({
-          rpId,
-          rpName,
-          userId: new TextEncoder().encode(userId),
-          userName: `decane-wallet-${authType}-${dateStr}`,
-          prfSalt
-        });
+        const { credentialId, prfOutput } = await registerWebAuthnCredential({ api, jwt, rpId, rpName, prfSalt });
         if (prfOutput) {
           unlockMethod = "passkey";
           wrappingKey = await importAesKey(prfOutput);
@@ -2595,19 +2942,21 @@ async function createDecaneConnect(config) {
       ({ wrappingKey, meta } = await pinSetup());
       unlockMethod = "pin";
     }
-    const { privateKey, deviceShare, serverShare } = generateWalletShares();
+    const master = generateMaster();
+    let shareSet;
     let evmAddress;
     let solanaAddress;
     try {
-      evmAddress = new Wallet(toHex(privateKey)).address;
-      solanaAddress = Keypair.fromSeed(privateKey).publicKey.toBase58();
+      evmAddress = new Wallet(toHex(master)).address;
+      solanaAddress = Keypair.fromSeed(master).publicKey.toBase58();
+      shareSet = await splitMaster(master, 1);
     } finally {
-      zeroize(privateKey);
+      zeroize(master);
     }
     const iv = generateRandomBytes(12);
     const wrappedDeviceShare = await aesGcmEncrypt(
       wrappingKey,
-      deviceShare,
+      shareSet.device,
       iv
     );
     await storage.putShare({
@@ -2623,7 +2972,7 @@ async function createDecaneConnect(config) {
     });
     const serverIv = generateRandomBytes(12);
     await api.putShare(jwt, {
-      ciphertext: serverShare,
+      ciphertext: shareSet.server,
       iv: serverIv,
       wrappedShareMeta: {
         unlockMethod
@@ -2632,7 +2981,7 @@ async function createDecaneConnect(config) {
       evmAddress,
       solanaAddress
     });
-    zeroize(serverShare);
+    zeroize(shareSet.server);
     const addresses = { evm: evmAddress, solana: solanaAddress };
     if (unlockMethod === "passkey" && meta.credentialId && meta.prfSalt) {
       try {
@@ -2647,32 +2996,47 @@ async function createDecaneConnect(config) {
         console.warn("decane-connect-kit: wrapped share backup failed; user can retry from settings.", e);
       }
     }
-    await session.start(deviceShare, jwt, addresses);
-    if (config.offerPhraseAtSignup !== false && config.onPhraseGenerated) {
+    const confirmed = await session.start(shareSet.device, jwt, addresses);
+    zeroize(shareSet.device);
+    if (confirmed.evm.toLowerCase() !== addresses.evm.toLowerCase()) {
+      console.warn(
+        `decane-connect-kit: signer derived a different EVM address (${confirmed.evm}) than this device did (${addresses.evm}) during setup. Using the signer's.`
+      );
+    }
+    addresses.evm = evmAddress = confirmed.evm;
+    addresses.solana = solanaAddress = confirmed.solana;
+    if (config.offerRecoveryAtSignup !== false && config.onRecoveryShareOffer) {
       try {
-        const result = buildPhraseResult(deviceShare);
-        const { userConfirmed, userAnswers } = await config.onPhraseGenerated(result);
-        if (userConfirmed && verifyConfirmationChallenge(result.challenge, userAnswers)) {
-          await api.markPhraseSaved(jwt);
+        const choice = await config.onRecoveryShareOffer({ evmAddress, solanaAddress });
+        if (choice.wants) {
+          const file = await buildRecoveryShareFile(
+            shareSet.recovery,
+            choice.password,
+            addresses,
+            shareSet.version,
+            choice.passwordHint
+          );
+          await config.onRecoveryFileReady?.(file, recoveryShareFileName(evmAddress));
+          await api.markRecoveryShareSaved(jwt);
         }
       } catch (e) {
-        console.warn("decane-connect-kit: recovery phrase offer failed or was skipped.", e);
+        console.warn("decane-connect-kit: recovery share offer failed or was skipped.", e);
       }
     }
-    zeroize(deviceShare);
+    zeroize(shareSet.recovery);
     return addresses;
   }
   async function returningUserUnlock(userId, jwt) {
     const rawAddresses = await api.getAddresses(jwt);
-    if (!rawAddresses.evm || !rawAddresses.solana) {
-      throw new CallSequenceError(
-        "No addresses are recorded for this user \u2014 inconsistent server state"
-      );
-    }
-    const addresses = { evm: rawAddresses.evm, solana: rawAddresses.solana };
+    const recordedAddresses = rawAddresses.evm && rawAddresses.solana ? { evm: rawAddresses.evm, solana: rawAddresses.solana } : null;
     const stored = await storage.getShare(userId);
     let deviceShare;
     if (!stored) {
+      if (!config.onRecoveryRotated) {
+        throw new CallSequenceError(
+          "Recovery rotates the share set and issues a new recovery file, but no onRecoveryRotated callback is configured to save it. Configure onRecoveryRotated before allowing recovery."
+        );
+      }
       deviceShare = await recoverDeviceShare({
         userId,
         jwt,
@@ -2681,7 +3045,15 @@ async function createDecaneConnect(config) {
         api,
         storage,
         onProgress: config.onRecoveryProgress,
-        promptForPhrase: config.promptForRecoveryPhrase
+        promptForRecoveryFile: config.promptForRecoveryFile,
+        onNewRecoveryShare: async (recoveryShare, shareSetVersion) => {
+          if (!config.onRecoveryRotated) return;
+          if (!recordedAddresses) return;
+          const { password, passwordHint } = await config.onRecoveryRotated({ evmAddress: recordedAddresses.evm, solanaAddress: recordedAddresses.solana });
+          const file = await buildRecoveryShareFile(recoveryShare, password, recordedAddresses, shareSetVersion, passwordHint);
+          await config.onRecoveryFileReady?.(file, recoveryShareFileName(recordedAddresses.evm));
+          await api.markRecoveryShareSaved(jwt);
+        }
       });
       if (!await storage.getShare(userId) && isPasskeySupported()) {
         await registerPasskeyAndBackup(userId, jwt, deviceShare);
@@ -2698,8 +3070,13 @@ async function createDecaneConnect(config) {
         throw stored.unlockMethod === "pin" ? new InvalidPinError() : new ShareCorruptedError();
       }
     }
-    await session.start(deviceShare, jwt, addresses);
+    const addresses = await session.start(deviceShare, jwt, recordedAddresses);
     zeroize(deviceShare);
+    if (recordedAddresses && recordedAddresses.evm.toLowerCase() !== addresses.evm.toLowerCase()) {
+      console.warn(
+        `decane-connect-kit: recorded EVM address (${recordedAddresses.evm}) does not match the signing key (${addresses.evm}). Using the signing key's address; the record has been corrected.`
+      );
+    }
     return addresses;
   }
   async function handleAuthResult(result) {
@@ -2761,14 +3138,24 @@ async function createDecaneConnect(config) {
       return handleAuthResult(result);
     },
     async unlock() {
-      if (!auth)
-        throw new CallSequenceError("Not connected \u2014 call connect() first");
+      if (!auth) {
+        throw persisted ? new ReconnectRequiredError() : new CallSequenceError("Not connected \u2014 call connect() first");
+      }
       if (session.isActive()) return;
       await returningUserUnlock(auth.userId, auth.jwt);
     },
     isUnlocked() {
       return session.isActive();
     },
+    /**
+     * True when we have a persisted identity but no live auth state, i.e.
+     * unlock() cannot succeed and the user must sign in again. Exposed on the
+     * client (not just the React context) so non-React consumers can branch on
+     * it without having to catch ReconnectRequiredError.
+     */
+    needsReconnect() {
+      return !auth && !!persisted;
+    },
     sessionExpiresAt() {
       return session.expiresAtTimestamp();
     },
@@ -2856,23 +3243,86 @@ async function createDecaneConnect(config) {
     getAddresses() {
       return auth?.addresses ?? persisted?.addresses ?? null;
     },
-    async generateRecoveryPhrase() {
+    async rotateShares(opts) {
       if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
-      const stored = await storage.getShare(auth.userId);
-      if (!stored) throw new NewDeviceError();
-      const wrappingKey = await getWrappingKey(stored);
-      const deviceShare = await aesGcmDecrypt(wrappingKey, stored.wrappedDeviceShare, stored.iv);
+      const tee = session.requireActive();
+      const result = await tee.rotateShares(auth.jwt);
       try {
-        return buildPhraseResult(deviceShare);
+        await persistRotatedDeviceShare(auth.userId, result.deviceShare);
+        const addresses = await deriveAddressesFromShares(result.deviceShare, result.recoveryShare);
+        const file = await buildRecoveryShareFile(
+          result.recoveryShare,
+          opts.password,
+          addresses,
+          result.shareSetVersion,
+          opts.passwordHint
+        );
+        await api.markRecoveryShareSaved(auth.jwt);
+        return file;
       } finally {
-        zeroize(deviceShare);
+        zeroize(result.deviceShare);
+        zeroize(result.recoveryShare);
       }
     },
-    async markPhraseSaved(challenge, userAnswers) {
+    async exportPortableBackup(opts) {
       if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
-      if (!verifyConfirmationChallenge(challenge, userAnswers)) return false;
-      await api.markPhraseSaved(auth.jwt);
-      return true;
+      const tee = session.requireActive();
+      const result = await tee.exportPortableBackup(auth.jwt);
+      try {
+        await persistRotatedDeviceShare(auth.userId, result.deviceShare);
+        const addresses = await deriveAddressesFromShares(result.deviceShare, result.recoveryShare);
+        return await buildPortableBackup(
+          result.deviceShare,
+          result.recoveryShare,
+          opts.password,
+          addresses,
+          result.shareSetVersion,
+          opts.passwordHint
+        );
+      } finally {
+        zeroize(result.deviceShare);
+        zeroize(result.recoveryShare);
+      }
+    },
+    async hasRecoveryShare() {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      const status = await api.getRecoveryStatus(auth.jwt);
+      return status.hasRecoveryShare;
+    },
+    async shouldPromptRecovery() {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      const status = await api.getRecoveryStatus(auth.jwt);
+      if (status.hasRecoveryShare || status.nagged) return false;
+      try {
+        const checks = [];
+        if (auth.addresses.evm) {
+          const { JsonRpcProvider } = await import("ethers");
+          for (const chain of config.chains.filter((c) => c.startsWith("evm:"))) {
+            const rpcUrl = config.rpcUrls?.[chain] ?? DEFAULT_RPCS[chain];
+            if (!rpcUrl) continue;
+            checks.push(
+              new JsonRpcProvider(rpcUrl).getBalance(auth.addresses.evm).then((b) => b > 0n).catch(() => false)
+            );
+          }
+        }
+        if (auth.addresses.solana && config.chains.some((c) => c.startsWith("solana:"))) {
+          const { Connection, PublicKey } = await import("@solana/web3.js");
+          const solChain = config.chains.find((c) => c.startsWith("solana:")) ?? "solana:mainnet";
+          const cluster = solChain.slice("solana:".length);
+          const endpoint = cluster === "devnet" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com";
+          checks.push(
+            new Connection(endpoint).getBalance(new PublicKey(auth.addresses.solana)).then((b) => b > 0).catch(() => false)
+          );
+        }
+        const results = await Promise.all(checks);
+        return results.some(Boolean);
+      } catch {
+        return false;
+      }
+    },
+    async dismissRecoveryPrompt() {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      await api.dismissRecoveryNag(auth.jwt);
     },
     async hasBackup() {
       if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
@@ -2887,16 +3337,30 @@ async function createDecaneConnect(config) {
   };
   return client;
 }
-function bufferToB64u(buf4) {
-  return btoa(String.fromCharCode(...buf4)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+function bufferToB64u(buf6) {
+  return btoa(String.fromCharCode(...buf6)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
 function b64uToBuffer(b64u) {
-  const b642 = b64u.replace(/-/g, "+").replace(/_/g, "/");
-  return Uint8Array.from(atob(b642), (c) => c.charCodeAt(0));
+  const b644 = b64u.replace(/-/g, "+").replace(/_/g, "/");
+  return Uint8Array.from(atob(b644), (c) => c.charCodeAt(0));
 }
 function toHex(bytes) {
   return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
+async function deriveAddressesFromShares(a, b) {
+  const master = await combineShares(a, b);
+  try {
+    return {
+      evm: new Wallet(toHex(master)).address,
+      solana: Keypair.fromSeed(master).publicKey.toBase58()
+    };
+  } finally {
+    zeroize(master);
+  }
+}
+
+// src/social/index.ts
+init_errors();
 
 // src/ui/WalletSelector.tsx
 import React2, { useEffect, useCallback, useState } from "react";
@@ -3819,6 +4283,15 @@ function countdown(expiresAt) {
   const secs = Math.max(0, Math.round((expiresAt - Date.now()) / 1e3));
   return `${Math.floor(secs / 60)}m ${String(secs % 60).padStart(2, "0")}s`;
 }
+function downloadJson(data, filename) {
+  const blob = new Blob([JSON.stringify(data, null, 2)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
 function CopyButton({ value }) {
   const [copied, setCopied] = useState2(false);
   async function copy() {
@@ -3846,7 +4319,54 @@ function CopyButton({ value }) {
     copied ? "\u2713" : "copy"
   );
 }
-function AddressRow({ label, address }) {
+function useBalance(kind, address, chain, rpcUrls) {
+  const [state, setState] = useState2({ loading: false, value: null, symbol: kind === "evm" ? "ETH" : "SOL" });
+  useEffect2(() => {
+    if (!address || !chain) return;
+    let cancelled = false;
+    setState((s) => ({ ...s, loading: true }));
+    (async () => {
+      try {
+        if (kind === "evm") {
+          const rpcUrl = rpcUrls?.[chain] ?? DEFAULT_RPCS[chain];
+          if (!rpcUrl) {
+            if (!cancelled) setState({ loading: false, value: null, symbol: "ETH" });
+            return;
+          }
+          const { JsonRpcProvider, formatEther } = await import("ethers");
+          const wei = await new JsonRpcProvider(rpcUrl).getBalance(address);
+          if (!cancelled) setState({ loading: false, value: formatEther(wei), symbol: "ETH" });
+        } else {
+          const cluster = chain.slice("solana:".length);
+          const endpoint = rpcUrls?.[chain] ?? (cluster === "devnet" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com");
+          const { Connection, PublicKey, LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+          const lamports = await new Connection(endpoint).getBalance(new PublicKey(address));
+          if (!cancelled) setState({ loading: false, value: String(lamports / LAMPORTS_PER_SOL), symbol: "SOL" });
+        }
+      } catch {
+        if (!cancelled) setState({ loading: false, value: null, symbol: kind === "evm" ? "ETH" : "SOL" });
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [kind, address, chain, rpcUrls]);
+  return state;
+}
+function formatBalance(value) {
+  if (value == null) return "\u2014";
+  const n = Number(value);
+  if (!Number.isFinite(n)) return value;
+  return n === 0 ? "0" : n < 1e-4 ? "<0.0001" : n.toFixed(4).replace(/\.?0+$/, "");
+}
+function AddressRow({
+  label,
+  address,
+  kind,
+  chain,
+  rpcUrls
+}) {
+  const balance = useBalance(kind, address, chain, rpcUrls);
   const short = `${address.slice(0, 8)}\u2026${address.slice(-6)}`;
   return /* @__PURE__ */ React3.createElement("div", { style: {
     background: "var(--dc-surface)",
@@ -3854,7 +4374,233 @@ function AddressRow({ label, address }) {
     borderRadius: 10,
     padding: "10px 14px",
     marginBottom: 8
-  } }, /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 10, fontWeight: 700, color: "var(--dc-text-muted)", letterSpacing: "0.06em", textTransform: "uppercase", marginBottom: 5 } }, label), /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between", gap: 8 } }, /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 13, fontFamily: "monospace", color: "var(--dc-text)", letterSpacing: "0.02em" } }, short), /* @__PURE__ */ React3.createElement(CopyButton, { value: address })));
+  } }, /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: 5 } }, /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 10, fontWeight: 700, color: "var(--dc-text-muted)", letterSpacing: "0.06em", textTransform: "uppercase" } }, label), /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 11, fontFamily: "monospace", color: "var(--dc-text)" } }, balance.loading ? "\u2026" : `${formatBalance(balance.value)} ${balance.symbol}`)), /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between", gap: 8 } }, /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 13, fontFamily: "monospace", color: "var(--dc-text)", letterSpacing: "0.02em" } }, short), /* @__PURE__ */ React3.createElement(CopyButton, { value: address })));
+}
+function SignInView({
+  onGoogleSignIn,
+  onEmailStart,
+  onEmailVerify,
+  authMethods,
+  resumeHint
+}) {
+  const [googleLoading, setGoogleLoading] = useState2(false);
+  const [email, setEmail] = useState2("");
+  const [code, setCode] = useState2("");
+  const [emailSent, setEmailSent] = useState2(false);
+  const [emailLoading, setEmailLoading] = useState2(false);
+  const [error, setError] = useState2("");
+  async function handleGoogle() {
+    setError("");
+    setGoogleLoading(true);
+    try {
+      await onGoogleSignIn();
+    } catch (e) {
+      setError(e.message);
+      setGoogleLoading(false);
+    }
+  }
+  async function handleEmailStart(e) {
+    e.preventDefault();
+    setError("");
+    setEmailLoading(true);
+    try {
+      await onEmailStart(email);
+      setEmailSent(true);
+    } catch (e2) {
+      setError(e2.message);
+    } finally {
+      setEmailLoading(false);
+    }
+  }
+  async function handleEmailVerify(e) {
+    e.preventDefault();
+    setError("");
+    setEmailLoading(true);
+    try {
+      await onEmailVerify(email, code);
+    } catch (e2) {
+      setError(e2.message);
+    } finally {
+      setEmailLoading(false);
+    }
+  }
+  const inputStyle = {
+    width: "100%",
+    background: "var(--dc-surface)",
+    border: "1px solid var(--dc-border)",
+    borderRadius: 8,
+    color: "var(--dc-text)",
+    padding: "9px 12px",
+    fontSize: 13,
+    outline: "none",
+    fontFamily: "inherit",
+    boxSizing: "border-box"
+  };
+  return /* @__PURE__ */ React3.createElement("div", { style: { padding: "0 16px 16px" } }, resumeHint && /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 12, color: "var(--dc-text-muted)", marginBottom: 12, textAlign: "center" } }, "Welcome back \u2014 sign in again to resume ", resumeHint), authMethods.includes("google") && /* @__PURE__ */ React3.createElement(
+    "button",
+    {
+      onClick: handleGoogle,
+      disabled: googleLoading,
+      style: {
+        width: "100%",
+        padding: "10px 0",
+        marginBottom: 10,
+        background: "var(--dc-accent)",
+        color: "var(--dc-accent-text)",
+        border: "none",
+        borderRadius: 10,
+        fontSize: 13,
+        fontWeight: 700,
+        cursor: googleLoading ? "not-allowed" : "pointer",
+        opacity: googleLoading ? 0.7 : 1,
+        fontFamily: "inherit"
+      }
+    },
+    googleLoading ? "Redirecting\u2026" : "Continue with Google"
+  ), authMethods.includes("email") && /* @__PURE__ */ React3.createElement(React3.Fragment, null, authMethods.includes("google") && /* @__PURE__ */ React3.createElement("div", { style: { textAlign: "center", color: "var(--dc-text-muted)", fontSize: 12, margin: "10px 0" } }, "\u2014 or \u2014"), !emailSent ? /* @__PURE__ */ React3.createElement("form", { onSubmit: handleEmailStart, style: { display: "flex", gap: 8 } }, /* @__PURE__ */ React3.createElement(
+    "input",
+    {
+      type: "email",
+      required: true,
+      placeholder: "your@email.com",
+      value: email,
+      onChange: (e) => setEmail(e.target.value),
+      style: { ...inputStyle, flex: 1 }
+    }
+  ), /* @__PURE__ */ React3.createElement("button", { type: "submit", disabled: emailLoading, style: {
+    padding: "0 16px",
+    background: "var(--dc-surface)",
+    border: "1px solid var(--dc-border)",
+    borderRadius: 8,
+    color: "var(--dc-text)",
+    fontSize: 13,
+    cursor: "pointer",
+    fontFamily: "inherit"
+  } }, emailLoading ? "\u2026" : "Send code")) : /* @__PURE__ */ React3.createElement("form", { onSubmit: handleEmailVerify, style: { display: "flex", gap: 8 } }, /* @__PURE__ */ React3.createElement(
+    "input",
+    {
+      placeholder: "6-digit code",
+      value: code,
+      maxLength: 6,
+      autoFocus: true,
+      onChange: (e) => setCode(e.target.value.replace(/\D/g, "")),
+      style: { ...inputStyle, flex: 1, letterSpacing: 4, textAlign: "center" }
+    }
+  ), /* @__PURE__ */ React3.createElement("button", { type: "submit", disabled: emailLoading, style: {
+    padding: "0 16px",
+    background: "var(--dc-accent)",
+    color: "var(--dc-accent-text)",
+    border: "none",
+    borderRadius: 8,
+    fontSize: 13,
+    fontWeight: 700,
+    cursor: "pointer",
+    fontFamily: "inherit"
+  } }, emailLoading ? "\u2026" : "Verify"))), error && /* @__PURE__ */ React3.createElement("div", { style: { marginTop: 10, fontSize: 12, color: "var(--dc-danger, #ff5533)" } }, error));
+}
+function RecoverySection({
+  addresses,
+  onRotateShares,
+  onExportPortableBackup
+}) {
+  const [expanded, setExpanded] = useState2(false);
+  const [mode, setMode] = useState2(null);
+  const [password, setPassword] = useState2("");
+  const [passwordHint, setPasswordHint] = useState2("");
+  const [confirmed, setConfirmed] = useState2(false);
+  const [busy, setBusy] = useState2(false);
+  const [result, setResult] = useState2(null);
+  const [error, setError] = useState2("");
+  function reset() {
+    setMode(null);
+    setPassword("");
+    setPasswordHint("");
+    setConfirmed(false);
+    setError("");
+  }
+  async function handleGenerate() {
+    if (!addresses?.evm || !mode) return;
+    if (password.length < 8) {
+      setError("Password must be at least 8 characters.");
+      return;
+    }
+    if (mode === "portable" && !confirmed) {
+      setError("Confirm you understand the risk first.");
+      return;
+    }
+    setBusy(true);
+    setError("");
+    try {
+      if (mode === "share") {
+        const file = await onRotateShares({ password, passwordHint: passwordHint || void 0 });
+        downloadJson(file, `decane-recovery-${addresses.evm.slice(0, 8)}.json`);
+        setResult({ kind: "share", version: file.shareSetVersion });
+      } else {
+        const file = await onExportPortableBackup({ password, passwordHint: passwordHint || void 0 });
+        downloadJson(file, `decane-PORTABLE-BACKUP-${addresses.evm.slice(0, 8)}.json`);
+        setResult({ kind: "portable", version: file.shareSetVersion });
+      }
+      reset();
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setBusy(false);
+    }
+  }
+  const inputStyle = {
+    width: "100%",
+    background: "var(--dc-bg)",
+    border: "1px solid var(--dc-border)",
+    borderRadius: 8,
+    color: "var(--dc-text)",
+    padding: "8px 10px",
+    fontSize: 12,
+    outline: "none",
+    fontFamily: "inherit",
+    boxSizing: "border-box"
+  };
+  const btnStyle = {
+    padding: "8px 12px",
+    borderRadius: 8,
+    fontSize: 12,
+    fontWeight: 700,
+    cursor: "pointer",
+    fontFamily: "inherit",
+    border: "none"
+  };
+  return /* @__PURE__ */ React3.createElement("div", { style: { margin: "0 16px 14px", border: "1px solid var(--dc-border)", borderRadius: 10, overflow: "hidden" } }, /* @__PURE__ */ React3.createElement(
+    "button",
+    {
+      onClick: () => setExpanded((v) => !v),
+      style: {
+        width: "100%",
+        padding: "10px 14px",
+        background: "var(--dc-surface)",
+        border: "none",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        cursor: "pointer",
+        fontFamily: "inherit"
+      }
+    },
+    /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 12, fontWeight: 700, color: "var(--dc-text)" } }, "Recovery"),
+    /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 11, color: "var(--dc-text-muted)" } }, expanded ? "\u25B2" : "\u25BC")
+  ), expanded && /* @__PURE__ */ React3.createElement("div", { style: { padding: "12px 14px", borderTop: "1px solid var(--dc-border)" } }, /* @__PURE__ */ React3.createElement("p", { style: { fontSize: 11, color: "var(--dc-text-muted)", lineHeight: 1.5, margin: "0 0 10px" } }, "Your wallet is split into three shares \u2014 device, server, and one that's yours to keep. Any two reconstruct it; one alone reveals nothing."), !mode && /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 8 } }, /* @__PURE__ */ React3.createElement("button", { onClick: () => {
+    reset();
+    setMode("share");
+  }, style: { ...btnStyle, background: "var(--dc-accent)", color: "var(--dc-accent-text)" } }, "Generate recovery-share file"), /* @__PURE__ */ React3.createElement("button", { onClick: () => {
+    reset();
+    setMode("portable");
+  }, style: { ...btnStyle, background: "transparent", border: "1px solid var(--dc-border)", color: "var(--dc-text)" } }, "Generate portable backup (Decane-is-down)")), mode === "share" && /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 8 } }, /* @__PURE__ */ React3.createElement("p", { style: { fontSize: 11, color: "var(--dc-text-muted)", margin: 0 } }, "One share \u2014 useless alone, safe to keep in a password manager or cloud drive. Generating a new one invalidates any previous recovery-share file."), /* @__PURE__ */ React3.createElement("input", { type: "password", placeholder: "Password (min 8 chars)", value: password, onChange: (e) => setPassword(e.target.value), style: inputStyle }), /* @__PURE__ */ React3.createElement("input", { placeholder: "Password hint (optional)", value: passwordHint, onChange: (e) => setPasswordHint(e.target.value), style: inputStyle }), error && /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 11, color: "var(--dc-danger, #ff5533)" } }, error), /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", gap: 8 } }, /* @__PURE__ */ React3.createElement("button", { onClick: handleGenerate, disabled: busy, style: { ...btnStyle, flex: 1, background: "var(--dc-accent)", color: "var(--dc-accent-text)" } }, busy ? "Generating\u2026" : "Generate & download"), /* @__PURE__ */ React3.createElement("button", { onClick: reset, style: { ...btnStyle, background: "transparent", border: "1px solid var(--dc-border)", color: "var(--dc-text-muted)" } }, "Cancel"))), mode === "portable" && /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 8 } }, /* @__PURE__ */ React3.createElement("div", { style: {
+    background: "rgba(255,85,51,0.08)",
+    border: "1px solid rgba(255,85,51,0.3)",
+    borderRadius: 8,
+    padding: "8px 10px",
+    fontSize: 11,
+    color: "#ff9977",
+    lineHeight: 1.5
+  } }, /* @__PURE__ */ React3.createElement("strong", { style: { display: "block", marginBottom: 3, color: "#ff5533" } }, "This file controls your wallet"), "Contains two shares \u2014 file plus password gives complete control. Keep it offline, not a cloud drive. This also invalidates your current recovery-share file."), /* @__PURE__ */ React3.createElement("label", { style: { display: "flex", alignItems: "center", gap: 6, fontSize: 11, color: "var(--dc-text)" } }, /* @__PURE__ */ React3.createElement("input", { type: "checkbox", checked: confirmed, onChange: (e) => setConfirmed(e.target.checked), style: { width: "auto" } }), "I understand this is a bearer secret"), /* @__PURE__ */ React3.createElement("input", { type: "password", placeholder: "Password (min 8 chars)", value: password, onChange: (e) => setPassword(e.target.value), style: inputStyle }), /* @__PURE__ */ React3.createElement("input", { placeholder: "Password hint (optional)", value: passwordHint, onChange: (e) => setPasswordHint(e.target.value), style: inputStyle }), error && /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 11, color: "var(--dc-danger, #ff5533)" } }, error), /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", gap: 8 } }, /* @__PURE__ */ React3.createElement("button", { onClick: handleGenerate, disabled: busy || !confirmed, style: { ...btnStyle, flex: 1, background: "var(--dc-accent)", color: "var(--dc-accent-text)" } }, busy ? "Generating\u2026" : "Generate & download"), /* @__PURE__ */ React3.createElement("button", { onClick: reset, style: { ...btnStyle, background: "transparent", border: "1px solid var(--dc-border)", color: "var(--dc-text-muted)" } }, "Cancel"))), result && /* @__PURE__ */ React3.createElement("div", { style: { marginTop: 10, fontSize: 11, color: "var(--dc-text-muted)", lineHeight: 1.5 } }, result.kind === "share" ? "Recovery-share file" : "Portable backup", " downloaded \u2014 share set is now version ", result.version, ". Any previous recovery file no longer works.")));
 }
 function SocialWalletModal({
   open,
@@ -3862,7 +4608,15 @@ function SocialWalletModal({
   theme = "auto",
   socialAuth,
   onUnlock,
-  onDisconnect
+  onDisconnect,
+  onGoogleSignIn,
+  onEmailStart,
+  onEmailVerify,
+  authMethods = ["google", "email"],
+  onRotateShares,
+  onExportPortableBackup,
+  rpcUrls,
+  chains
 }) {
   const [timer, setTimer] = useState2("");
   const [unlocking, setUnlocking] = useState2(false);
@@ -3911,6 +4665,9 @@ function SocialWalletModal({
       setDisconnecting(false);
     }
   }
+  const evmChain = chains?.find((c) => c.startsWith("evm:")) ?? "evm:11155111";
+  const solChain = chains?.find((c) => c.startsWith("solana:")) ?? "solana:mainnet";
+  const showSignIn = !socialAuth.addresses || socialAuth.needsReconnect;
   const modal = /* @__PURE__ */ React3.createElement(
     "div",
     {
@@ -3948,10 +4705,14 @@ function SocialWalletModal({
       borderRadius: 20,
       width: "100%",
       maxWidth: 380,
-      boxShadow: "0 24px 64px rgba(0,0,0,0.6), 0 0 0 1px rgba(255,255,255,0.04)",
-      overflow: "hidden"
+      maxHeight: "90vh",
+      overflowY: "auto",
+      boxShadow: "0 24px 64px rgba(0,0,0,0.6), 0 0 0 1px rgba(255,255,255,0.04)"
     } }, /* @__PURE__ */ React3.createElement("div", { style: {
       height: 2,
+      position: "sticky",
+      top: 0,
+      zIndex: 1,
       background: "linear-gradient(90deg, transparent, var(--dc-accent) 30%, var(--dc-accent) 70%, transparent)"
     } }), /* @__PURE__ */ React3.createElement("div", { style: { padding: "18px 20px 16px", display: "flex", alignItems: "center", gap: 10 } }, /* @__PURE__ */ React3.createElement("div", { style: {
       width: 34,
@@ -3980,7 +4741,7 @@ function SocialWalletModal({
         strokeLinecap: "round",
         strokeLinejoin: "round"
       }
-    ))), /* @__PURE__ */ React3.createElement("div", { style: { flex: 1 } }, /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 15, fontWeight: 800, color: "var(--dc-text)", letterSpacing: "-0.02em" } }, "Social Wallet"), /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 11, color: "var(--dc-text-muted)", marginTop: 1 } }, "Decane non-custodial \xB7 key split between device & server")), /* @__PURE__ */ React3.createElement(
+    ))), /* @__PURE__ */ React3.createElement("div", { style: { flex: 1 } }, /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 15, fontWeight: 800, color: "var(--dc-text)", letterSpacing: "-0.02em" } }, "Social Wallet"), /* @__PURE__ */ React3.createElement("div", { style: { fontSize: 11, color: "var(--dc-text-muted)", marginTop: 1 } }, "Decane non-custodial \xB7 key split three ways")), /* @__PURE__ */ React3.createElement(
       "button",
       {
         onClick: onClose,
@@ -4000,7 +4761,16 @@ function SocialWalletModal({
         }
       },
       /* @__PURE__ */ React3.createElement("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none" }, /* @__PURE__ */ React3.createElement("path", { d: "M1.5 1.5L10.5 10.5M10.5 1.5L1.5 10.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round" }))
-    )), /* @__PURE__ */ React3.createElement("div", { style: {
+    )), showSignIn ? /* @__PURE__ */ React3.createElement(
+      SignInView,
+      {
+        onGoogleSignIn,
+        onEmailStart,
+        onEmailVerify,
+        authMethods,
+        resumeHint: socialAuth.needsReconnect ? "your wallet" : void 0
+      }
+    ) : /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement("div", { style: {
       margin: "0 16px 14px",
       padding: "8px 14px",
       background: socialAuth.isUnlocked ? "rgba(18,183,106,0.08)" : "rgba(245,200,0,0.08)",
@@ -4020,7 +4790,14 @@ function SocialWalletModal({
       fontSize: 12,
       fontWeight: 700,
       color: socialAuth.isUnlocked ? "#12b76a" : "var(--dc-accent)"
-    } }, socialAuth.isUnlocked ? "Unlocked" : "Locked")), socialAuth.isUnlocked && timer && /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 11, color: "var(--dc-text-muted)", fontFamily: "monospace" } }, "expires ", timer)), /* @__PURE__ */ React3.createElement("div", { style: { padding: "0 16px 16px" } }, socialAuth.addresses?.evm && /* @__PURE__ */ React3.createElement(AddressRow, { label: "EVM (Ethereum, Base, \u2026)", address: socialAuth.addresses.evm }), socialAuth.addresses?.solana && /* @__PURE__ */ React3.createElement(AddressRow, { label: "Solana", address: socialAuth.addresses.solana }), !socialAuth.addresses?.evm && !socialAuth.addresses?.solana && /* @__PURE__ */ React3.createElement("div", { style: { textAlign: "center", padding: "16px 0", color: "var(--dc-text-muted)", fontSize: 13 } }, "Unlock wallet to reveal addresses")), /* @__PURE__ */ React3.createElement("div", { style: {
+    } }, socialAuth.isUnlocked ? "Unlocked" : "Locked")), socialAuth.isUnlocked && timer && /* @__PURE__ */ React3.createElement("span", { style: { fontSize: 11, color: "var(--dc-text-muted)", fontFamily: "monospace" } }, "expires ", timer)), /* @__PURE__ */ React3.createElement("div", { style: { padding: "0 16px 14px" } }, socialAuth.addresses?.evm && /* @__PURE__ */ React3.createElement(AddressRow, { label: "EVM (Ethereum, Base, \u2026)", address: socialAuth.addresses.evm, kind: "evm", chain: evmChain, rpcUrls }), socialAuth.addresses?.solana && /* @__PURE__ */ React3.createElement(AddressRow, { label: "Solana", address: socialAuth.addresses.solana, kind: "solana", chain: solChain, rpcUrls })), socialAuth.isUnlocked && /* @__PURE__ */ React3.createElement(
+      RecoverySection,
+      {
+        addresses: socialAuth.addresses,
+        onRotateShares,
+        onExportPortableBackup
+      }
+    ), /* @__PURE__ */ React3.createElement("div", { style: {
       padding: "14px 16px",
       borderTop: "1px solid var(--dc-border)",
       display: "flex",
@@ -4065,7 +4842,7 @@ function SocialWalletModal({
         }
       },
       disconnecting ? "Signing out\u2026" : "Sign out"
-    )))
+    ))))
   );
   return createPortal2(modal, document.body);
 }
@@ -4083,7 +4860,8 @@ var DEFAULT_SOCIAL = {
   addresses: null,
   isNewUser: false,
   isUnlocked: false,
-  sessionExpiresAt: null
+  sessionExpiresAt: null,
+  needsReconnect: false
 };
 var DecaneContext = createContext(null);
 function hasSocial(mode) {
@@ -4143,7 +4921,7 @@ function DecaneKit({ config, children }) {
       sdk.on("disconnected", () => setSocialAuth(DEFAULT_SOCIAL));
       const saved = sdk.getAddresses();
       if (saved) {
-        setSocialAuth((p) => ({ ...p, addresses: saved, isUnlocked: false }));
+        setSocialAuth((p) => ({ ...p, addresses: saved, isUnlocked: false, needsReconnect: true }));
       }
       const params = new URLSearchParams(window.location.search);
       if (params.has("decane_jwt") || params.has("decane_error")) {
@@ -4157,7 +4935,8 @@ function DecaneKit({ config, children }) {
       addresses: result.addresses,
       isNewUser: result.isNewUser,
       isUnlocked: sdk?.isUnlocked() ?? false,
-      sessionExpiresAt: sdk?.sessionExpiresAt() ?? null
+      sessionExpiresAt: sdk?.sessionExpiresAt() ?? null,
+      needsReconnect: false
     });
   }
   const connectWithGoogle = useCallback3(async () => {
@@ -4184,7 +4963,8 @@ function DecaneKit({ config, children }) {
     setSocialAuth((p) => ({
       ...p,
       isUnlocked: sdk.isUnlocked(),
-      sessionExpiresAt: sdk.sessionExpiresAt()
+      sessionExpiresAt: sdk.sessionExpiresAt(),
+      needsReconnect: false
     }));
   }, []);
   const socialDisconnect = useCallback3(async () => {
@@ -4208,6 +4988,31 @@ function DecaneKit({ config, children }) {
     if (!sdk) throw new Error("Social wallet not connected");
     return sdk.signSolanaTransaction(tx);
   }, []);
+  const socialRotateShares = useCallback3(async (opts) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.rotateShares(opts);
+  }, []);
+  const socialExportPortableBackup = useCallback3(async (opts) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.exportPortableBackup(opts);
+  }, []);
+  const socialHasRecoveryShare = useCallback3(async () => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.hasRecoveryShare();
+  }, []);
+  const socialShouldPromptRecovery = useCallback3(async () => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.shouldPromptRecovery();
+  }, []);
+  const socialDismissRecoveryPrompt = useCallback3(async () => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.dismissRecoveryPrompt();
+  }, []);
   const handleWalletConnect = useCallback3(
     (wallet, preference) => {
       walletRef.current.connect(wallet, preference).catch(console.error);
@@ -4235,6 +5040,11 @@ function DecaneKit({ config, children }) {
         socialSignMessage,
         socialSendTransaction,
         socialSignSolanaTransaction,
+        socialRotateShares,
+        socialExportPortableBackup,
+        socialHasRecoveryShare,
+        socialShouldPromptRecovery,
+        socialDismissRecoveryPrompt,
         socialModalOpen,
         openSocialModal,
         closeSocialModal
@@ -4265,7 +5075,15 @@ function DecaneKit({ config, children }) {
         theme,
         socialAuth,
         onUnlock: socialUnlock,
-        onDisconnect: socialDisconnect
+        onDisconnect: socialDisconnect,
+        onGoogleSignIn: connectWithGoogle,
+        onEmailStart: connectWithEmail,
+        onEmailVerify: verifyEmailCode2,
+        authMethods: config?.social?.authMethods ?? ["google", "email"],
+        onRotateShares: socialRotateShares,
+        onExportPortableBackup: socialExportPortableBackup,
+        rpcUrls: config?.social?.rpcUrls,
+        chains: config?.social?.chains
       }
     )
   );
@@ -4353,6 +5171,11 @@ function useSocialAuth() {
     isNewUser: socialAuth.isNewUser,
     addresses: socialAuth.addresses,
     sessionExpiresAt: socialAuth.sessionExpiresAt,
+    // True when addresses are known (from a previous visit) but there's no
+    // live session — unlock() will always throw in this state (every
+    // unlock requires a fresh JWT, and JWTs are never persisted). Route
+    // this into a real reconnect (signInWithGoogle / sendEmailCode), not unlock().
+    needsReconnect: socialAuth.needsReconnect,
     googleLoading,
     emailLoading,
     error,
@@ -4372,6 +5195,11 @@ function useSocialWallet() {
     socialSignMessage,
     socialSendTransaction,
     socialSignSolanaTransaction,
+    socialRotateShares,
+    socialExportPortableBackup,
+    socialHasRecoveryShare,
+    socialShouldPromptRecovery,
+    socialDismissRecoveryPrompt,
     openSocialModal,
     closeSocialModal,
     socialModalOpen
@@ -4421,6 +5249,26 @@ function useSocialWallet() {
       throw e;
     }
   }, [socialDisconnect]);
+  const rotateShares = useCallback4(
+    (opts) => run(() => socialRotateShares(opts)),
+    [socialRotateShares]
+  );
+  const exportPortableBackup = useCallback4(
+    (opts) => run(() => socialExportPortableBackup(opts)),
+    [socialExportPortableBackup]
+  );
+  const hasRecoveryShare = useCallback4(
+    () => run(() => socialHasRecoveryShare()),
+    [socialHasRecoveryShare]
+  );
+  const shouldPromptRecovery = useCallback4(
+    () => run(() => socialShouldPromptRecovery()),
+    [socialShouldPromptRecovery]
+  );
+  const dismissRecoveryPrompt = useCallback4(
+    () => run(() => socialDismissRecoveryPrompt()),
+    [socialDismissRecoveryPrompt]
+  );
   return {
     // State
     isConnected: !!socialAuth.addresses,
@@ -4428,6 +5276,11 @@ function useSocialWallet() {
     isNewUser: socialAuth.isNewUser,
     addresses: socialAuth.addresses,
     sessionExpiresAt: socialAuth.sessionExpiresAt,
+    // True when addresses are known (from a previous visit) but there's no
+    // live session — unlock() will always throw in this state (every
+    // unlock requires a fresh JWT, and JWTs are never persisted). Route
+    // this into a real reconnect (signInWithGoogle / sendEmailCode), not unlock().
+    needsReconnect: socialAuth.needsReconnect,
     // Modal
     modalOpen: socialModalOpen,
     openModal: openSocialModal,
@@ -4439,6 +5292,12 @@ function useSocialWallet() {
     signMessage,
     sendTransaction,
     signSolanaTransaction: signSolanaTransaction2,
+    // Recovery (2-of-3 Shamir share set)
+    rotateShares,
+    exportPortableBackup,
+    hasRecoveryShare,
+    shouldPromptRecovery,
+    dismissRecoveryPrompt,
     loading,
     error,
     clearError: () => setError(null)
@@ -4676,14 +5535,17 @@ export {
   DecaneError,
   DecaneErrorCode,
   DecaneKit,
+  ExportNotAuthorizedError,
   InvalidApiKeyError,
-  InvalidPhraseError,
   InvalidPinError,
+  InvalidRecoveryFileError,
   NetworkError,
   NewDeviceError,
   OriginNotAllowedError,
   PromptPinNotConfiguredError,
+  ReconnectRequiredError,
   RecoveryFailedError,
+  RecoveryWalletMismatchError,
   SessionExpiredError,
   ShareCorruptedError,
   SocialWalletModal,
@@ -4691,6 +5553,7 @@ export {
   UserCancelledError,
   WalletSelector,
   WebAuthnNotSupportedError,
+  WrongPasswordError,
   createDecane,
   createDecaneConnect,
   startEmailAuth,