decane-connect-kit 1.0.2 → 2.0.0

package/dist/index.js

@@ -1,3 +1,145 @@
+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,
+  RecoveryFailedError: () => RecoveryFailedError,
+  RecoveryWalletMismatchError: () => RecoveryWalletMismatchError,
+  SessionExpiredError: () => SessionExpiredError,
+  ShareCorruptedError: () => ShareCorruptedError,
+  UnlockRequiredError: () => UnlockRequiredError,
+  UserCancelledError: () => UserCancelledError,
+  WebAuthnNotSupportedError: () => WebAuthnNotSupportedError,
+  WrongPasswordError: () => WrongPasswordError
+});
+var DecaneConnectError, InvalidApiKeyError, OriginNotAllowedError, SessionExpiredError, UnlockRequiredError, 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);
+      }
+    };
+    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();
@@ -1670,6 +1812,7 @@ function startSolanaDiscovery(registry) {
 var TRONLINK_RDNS = "link.tron.tronlink";
 var TRONLINK_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiI+PGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMTYiIGZpbGw9IiNGRjAwMTMiLz48cG9seWdvbiBwb2ludHM9IjEyLDkgMjMsMTYgMTIsMjMiIGZpbGw9IndoaXRlIi8+PC9zdmc+";
 function startTronDiscovery(registry) {
+  if (typeof window === "undefined") return;
   let registered = false;
   function tryRegister() {
     if (registered || !window.tronLink) return;
@@ -1694,6 +1837,7 @@ function startTronDiscovery(registry) {
 // src/bitcoin/discovery.ts
 var BTC_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiI+PGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMTYiIGZpbGw9IiNGNzkzMUEiLz48dGV4dCB4PSIxNi41IiB5PSIyMiIgdGV4dC1hbmNob3I9Im1pZGRsZSIgZm9udC1zaXplPSIxNiIgZm9udC13ZWlnaHQ9IjcwMCIgZmlsbD0id2hpdGUiIGZvbnQtZmFtaWx5PSJBcmlhbCxzeXN0ZW0tdWkiPuKmojwvdGV4dD48L3N2Zz4=";
 function startBitcoinDiscovery(registry) {
+  if (typeof window === "undefined") return;
   setTimeout(() => {
     const candidates = [
       { name: "Unisat", rdns: "io.unisat.wallet", provider: window.unisat },
@@ -1731,160 +1875,1560 @@ function createDecane(config = {}) {
   return createProvider({ config, registry, session, chainStore, router, emitter });
 }
 
-// src/ui/WalletSelector.tsx
-import React2, { useEffect, useCallback, useState } from "react";
-import { createPortal } from "react-dom";
+// src/social/client.ts
+init_errors();
+import { Wallet } from "ethers";
+import { Transaction as Transaction2, VersionedTransaction, Keypair } from "@solana/web3.js";
 
-// src/ui/styles.ts
-var tokens = {
-  // ── Gold palette ──────────────────────────────────────────────────────────
-  gold: {
-    50: "#FFFDF0",
-    100: "#FFF8D6",
-    200: "#FFEF99",
-    300: "#FFE04D",
-    400: "#F5C800",
-    // primary gold — buttons, accents
-    500: "#D4A800",
-    // darker gold — hover states
-    600: "#A37F00",
-    // deep gold — borders, active
-    700: "#7A5E00",
-    800: "#4D3B00",
-    900: "#261D00"
-  },
-  // ── Black / dark palette ──────────────────────────────────────────────────
-  black: {
-    0: "#FFFFFF",
-    50: "#F9F9F7",
-    100: "#F0EFEB",
-    200: "#DDDCDA",
-    300: "#BDBBB8",
-    400: "#8A8884",
-    500: "#5C5A57",
-    600: "#3D3C39",
-    700: "#2A2927",
-    800: "#1A1917",
-    900: "#0D0D0B",
-    950: "#070706"
-  },
-  // ── Semantic tokens — light mode ──────────────────────────────────────────
-  light: {
-    bg: "#FFFFFF",
-    bgOverlay: "rgba(0, 0, 0, 0.55)",
-    surface: "#F9F9F7",
-    surfaceHover: "#F0EFEB",
-    border: "#DDDCDA",
-    borderAccent: "#F5C800",
-    text: "#0D0D0B",
-    textSecondary: "#5C5A57",
-    textMuted: "#8A8884",
-    accent: "#F5C800",
-    accentHover: "#D4A800",
-    accentText: "#0D0D0B",
-    badgeEvm: "#1A1917",
-    badgeEvmText: "#F5C800",
-    badgeSolana: "#F5C800",
-    badgeSolanaText: "#0D0D0B",
-    danger: "#CC3300"
-  },
-  // ── Semantic tokens — dark mode ───────────────────────────────────────────
-  dark: {
-    bg: "#0D0D0B",
-    bgOverlay: "rgba(0, 0, 0, 0.75)",
-    surface: "#1A1917",
-    surfaceHover: "#2A2927",
-    border: "#3D3C39",
-    borderAccent: "#F5C800",
-    text: "#F9F9F7",
-    textSecondary: "#BDBBB8",
-    textMuted: "#8A8884",
-    accent: "#F5C800",
-    accentHover: "#FFE04D",
-    accentText: "#0D0D0B",
-    badgeEvm: "#F5C800",
-    badgeEvmText: "#0D0D0B",
-    badgeSolana: "#1A1917",
-    badgeSolanaText: "#F5C800",
-    danger: "#FF5533"
+// src/social/events.ts
+var EventEmitter = class {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Map();
+  }
+  emit(event, ...args) {
+    this._listeners.get(event)?.forEach((h) => h(...args));
+  }
+  on(event, handler) {
+    if (!this._listeners.has(event)) this._listeners.set(event, /* @__PURE__ */ new Set());
+    this._listeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    this._listeners.get(event)?.delete(handler);
   }
 };
-var FONT_SANS = "'Plus Jakarta Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
-var FONT_MONO = "'JetBrains Mono', 'Fira Code', ui-monospace, monospace";
-var CSS_VARS = {
-  light: `
-    --dc-font-sans:       ${FONT_SANS};
-    --dc-font-mono:       ${FONT_MONO};
-    --dc-bg:              ${tokens.light.bg};
-    --dc-bg-overlay:      ${tokens.light.bgOverlay};
-    --dc-surface:         ${tokens.light.surface};
-    --dc-surface-hover:   ${tokens.light.surfaceHover};
-    --dc-border:          ${tokens.light.border};
-    --dc-border-accent:   ${tokens.light.borderAccent};
-    --dc-text:            ${tokens.light.text};
-    --dc-text-secondary:  ${tokens.light.textSecondary};
-    --dc-text-muted:      ${tokens.light.textMuted};
-    --dc-accent:          ${tokens.light.accent};
-    --dc-accent-hover:    ${tokens.light.accentHover};
-    --dc-accent-text:     ${tokens.light.accentText};
-    --dc-badge-evm:       ${tokens.light.badgeEvm};
-    --dc-badge-evm-text:  ${tokens.light.badgeEvmText};
-    --dc-badge-sol:       ${tokens.light.badgeSolana};
-    --dc-badge-sol-text:  ${tokens.light.badgeSolanaText};
-    --dc-danger:          ${tokens.light.danger};
-  `,
-  dark: `
-    --dc-font-sans:       ${FONT_SANS};
-    --dc-font-mono:       ${FONT_MONO};
-    --dc-bg:              ${tokens.dark.bg};
-    --dc-bg-overlay:      ${tokens.dark.bgOverlay};
-    --dc-surface:         ${tokens.dark.surface};
-    --dc-surface-hover:   ${tokens.dark.surfaceHover};
-    --dc-border:          ${tokens.dark.border};
-    --dc-border-accent:   ${tokens.dark.borderAccent};
-    --dc-text:            ${tokens.dark.text};
-    --dc-text-secondary:  ${tokens.dark.textSecondary};
-    --dc-text-muted:      ${tokens.dark.textMuted};
-    --dc-accent:          ${tokens.dark.accent};
-    --dc-accent-hover:    ${tokens.dark.accentHover};
-    --dc-accent-text:     ${tokens.dark.accentText};
-    --dc-badge-evm:       ${tokens.dark.badgeEvm};
-    --dc-badge-evm-text:  ${tokens.dark.badgeEvmText};
-    --dc-badge-sol:       ${tokens.dark.badgeSolana};
-    --dc-badge-sol-text:  ${tokens.dark.badgeSolanaText};
-    --dc-danger:          ${tokens.dark.danger};
-  `
+
+// src/social/api.ts
+init_errors();
+var ERROR_MAP = {
+  INVALID_API_KEY: InvalidApiKeyError,
+  ORIGIN_NOT_ALLOWED: OriginNotAllowedError
+};
+var ApiClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async _request(path, init) {
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.apiKey,
+          ...init?.headers
+        }
+      });
+    } catch {
+      throw new NetworkError();
+    }
+    if (res.status === 404 && init?.allow404) return null;
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      const code = body?.error?.code ?? "UNKNOWN";
+      const msg = body?.error?.message ?? `Request failed: ${res.status}`;
+      const Ctor = ERROR_MAP[code];
+      if (Ctor) throw new Ctor(msg);
+      throw new Error(msg);
+    }
+    return res.json();
+  }
+  async getGoogleInitUrl() {
+    return this._request("/auth/google/init", { method: "GET" });
+  }
+  async authEmailStart(email) {
+    await this._request("/auth/email/start", {
+      method: "POST",
+      body: JSON.stringify({ email })
+    });
+  }
+  async authEmailVerify(email, code) {
+    return this._request("/auth/email/verify", {
+      method: "POST",
+      body: JSON.stringify({ email, code })
+    });
+  }
+  // GET /share (the server share itself) was removed as part of the TEE
+  // migration — the browser must never reconstruct the private key anymore.
+  // Only public addresses are fetched from the backend now.
+  async getAddresses(jwt) {
+    return this._request("/share/addresses", {
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+  }
+  async putShare(jwt, share) {
+    await this._request("/share", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` },
+      body: JSON.stringify({
+        ciphertext: bytesToB64(share.ciphertext),
+        iv: bytesToB64(share.iv),
+        wrappedShareMeta: btoa(JSON.stringify(share.wrappedShareMeta)),
+        evmAddress: share.evmAddress,
+        solanaAddress: share.solanaAddress
+      })
+    });
+  }
+  // ── 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 + recovery-share-saved flag) ────────────
+  async hasRecoveryBackup(jwt) {
+    const data = await this._request("/recovery/backup/exists", {
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+    return data.exists;
+  }
+  async getRecoveryBackup(jwt) {
+    const data = await this._request("/recovery/backup", {
+      headers: { Authorization: `Bearer ${jwt}` },
+      allow404: true
+    });
+    if (!data) return null;
+    return {
+      wrappedDeviceShare: b64ToBytes(data.wrappedDeviceShare),
+      iv: b64ToBytes(data.iv),
+      unlockMethod: data.unlockMethod,
+      credentialId: b64ToBytes(data.credentialId),
+      prfSalt: b64ToBytes(data.prfSalt),
+      formatVersion: data.formatVersion
+    };
+  }
+  async putRecoveryBackup(jwt, backup) {
+    await this._request("/recovery/backup", {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${jwt}` },
+      body: JSON.stringify({
+        wrappedDeviceShare: bytesToB64(backup.wrappedDeviceShare),
+        iv: bytesToB64(backup.iv),
+        unlockMethod: backup.unlockMethod,
+        credentialId: bytesToB64(backup.credentialId),
+        prfSalt: bytesToB64(backup.prfSalt)
+      })
+    });
+  }
+  async deleteRecoveryBackup(jwt) {
+    await this._request("/recovery/backup", {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+  }
+  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}` }
+    });
+  }
 };
+function bytesToB64(bytes) {
+  return btoa(String.fromCharCode(...bytes));
+}
+function b64ToBytes(b644) {
+  return Uint8Array.from(atob(b644), (c) => c.charCodeAt(0));
+}
 
-// src/ui/icons.tsx
-import React from "react";
-function WalletIcon({ src, name, size = 36 }) {
-  if (src) {
-    return /* @__PURE__ */ React.createElement(
-      "img",
-      {
-        src,
-        alt: name,
-        width: size,
-        height: size,
-        style: { borderRadius: size * 0.25, objectFit: "cover", flexShrink: 0 }
+// src/social/storage.ts
+import { openDB } from "idb";
+var DB_NAME = "decane-connect-kit";
+var STORE = "shares";
+var Storage = class {
+  constructor() {
+    this._db = openDB(DB_NAME, 1, {
+      upgrade(db) {
+        db.createObjectStore(STORE, { keyPath: "userId" });
       }
+    });
+  }
+  async getShare(userId) {
+    return (await this._db).get(STORE, userId) ?? null;
+  }
+  async putShare(share) {
+    await (await this._db).put(STORE, share);
+  }
+  async deleteShare(userId) {
+    await (await this._db).delete(STORE, userId);
+  }
+};
+
+// 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
+var tee_measurement_default = {
+  signerVersion: "0.1.3",
+  acceptedMrtd: [
+    '["68102e7b524af310f7b7d426ce75481e36c40f5d513a9009c046e9d37e31551f0134d954b496a3357fd61d03f07ffe96","07e6f51aa763abfe75c3ddfbf4f425fe3f0ceff66d807a75e049303dce9addf68e7218729bd419638af63a370f65878c","a2a58c9a959a4fa44bd6da0c97a2270c051faf12084cfe91ae900e4fdff6cdd4f69a82005e04ee920f231497894d677f","a76a81147b7f733cb400914c8791ec149bb3a31f3727b1c1e12ec22e9c1a183b6e617e78636dca37075f5a695afd46c2"]'
+  ],
+  primaryMrtd: '["68102e7b524af310f7b7d426ce75481e36c40f5d513a9009c046e9d37e31551f0134d954b496a3357fd61d03f07ffe96","07e6f51aa763abfe75c3ddfbf4f425fe3f0ceff66d807a75e049303dce9addf68e7218729bd419638af63a370f65878c","a2a58c9a959a4fa44bd6da0c97a2270c051faf12084cfe91ae900e4fdff6cdd4f69a82005e04ee920f231497894d677f","a76a81147b7f733cb400914c8791ec149bb3a31f3727b1c1e12ec22e9c1a183b6e617e78636dca37075f5a695afd46c2"]',
+  capturedAt: "2026-07-20T10:08:58.717Z",
+  tcbStatus: "UpToDate",
+  _note: "Captured from a live, signature-verified TDX quote (getCollateralAndVerify -> UpToDate) against decane-tee-signer v0.1.3 running on Phala Cloud CVM 786e714d-5042-4bf1-8060-0bc358f6a72f. measurement is the JSON.stringify(replayRtmrs()) output, compared as an opaque string (not parsed per-RTMR), matching the actual comparison logic in social/attestation.ts."
+};
+
+// src/social/attestation.ts
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(Math.floor(clean.length / 2));
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verifyTeeAttestation(teeUrl, nonce) {
+  const res = await fetch(`${teeUrl}/attestation`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ nonce })
+  });
+  if (!res.ok) throw new AttestationError("quote fetch failed");
+  const { quote, measurement } = await res.json();
+  let verified;
+  try {
+    verified = await getCollateralAndVerify(hexToBytes(quote));
+  } catch {
+    throw new AttestationError("quote signature invalid");
+  }
+  if (verified.status === "Revoked") {
+    throw new AttestationError("TEE platform TCB status is Revoked");
+  }
+  const td = verified.report.asTd10() ?? verified.report.asTd15()?.base;
+  if (!td) throw new AttestationError("quote is not a TDX report");
+  const reportDataHex = bytesToHex(td.reportData);
+  if (!reportDataHex.toLowerCase().startsWith(nonce.toLowerCase())) {
+    throw new AttestationError("quote nonce mismatch");
+  }
+  const accepted = tee_measurement_default.acceptedMrtd.map((m) => m.toLowerCase());
+  if (!accepted.includes(String(measurement).toLowerCase())) {
+    throw new AttestationError(
+      `TEE measurement not accepted. Got ${measurement}, expected one of ${accepted.join(", ") || "(none configured yet)"}`
     );
   }
-  const initial = name.charAt(0).toUpperCase();
-  return /* @__PURE__ */ React.createElement(
-    "div",
-    {
-      style: {
-        width: size,
-        height: size,
-        borderRadius: size * 0.25,
-        background: "linear-gradient(135deg, var(--dc-surface-hover), var(--dc-surface-active, var(--dc-surface-hover)))",
-        border: "1px solid var(--dc-border)",
-        display: "flex",
-        alignItems: "center",
-        justifyContent: "center",
-        fontSize: size * 0.38,
+}
+
+// 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;
+    this.handle = null;
+    this.attested = false;
+  }
+  async ensureAttested() {
+    if (this.attested) return;
+    const nonce = crypto.getRandomValues(new Uint8Array(16));
+    const nonceHex = Array.from(nonce).map((b) => b.toString(16).padStart(2, "0")).join("");
+    await verifyTeeAttestation(this.teeUrl, nonceHex);
+    this.attested = true;
+  }
+  async openSession(deviceShare, jwt) {
+    await this.ensureAttested();
+    const res = await fetch(`${this.teeUrl}/signer/session`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ deviceShare: bytesToBase64(deviceShare) })
+    });
+    if (!res.ok) throw new Error("session open failed");
+    this.handle = (await res.json()).handle;
+  }
+  /**
+   * 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/recover`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}`, "Content-Type": "application/json" },
+      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) 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;
+  }
+  async sign(req) {
+    if (!this.handle) throw new Error("no session");
+    const res = await fetch(`${this.teeUrl}/signer/sign`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ handle: this.handle, ...req })
+    });
+    if (res.status === 401) {
+      this.handle = null;
+      throw new SessionExpiredError();
+    }
+    if (!res.ok) throw new Error("sign failed");
+    return (await res.json()).signature;
+  }
+  async closeSession() {
+    if (!this.handle) return;
+    const handle = this.handle;
+    this.handle = null;
+    void fetch(`${this.teeUrl}/signer/close`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ handle })
+    }).catch(() => {
+    });
+  }
+};
+
+// src/social/session.ts
+init_errors();
+var SessionManager = class {
+  constructor(events, durationMs, teeUrl) {
+    this.events = events;
+    this.durationMs = durationMs;
+    this.teeUrl = teeUrl;
+    this.tee = null;
+    this.evmAddress = null;
+    this.solanaAddress = null;
+    this.expiresAt = null;
+    this.timeoutId = null;
+    if (typeof window !== "undefined") {
+      window.addEventListener("pagehide", () => this.end());
+    }
+  }
+  async start(deviceShare, jwt, addresses) {
+    this.tee = new TeeClient(this.teeUrl);
+    await this.tee.openSession(deviceShare, jwt);
+    this.evmAddress = addresses.evm;
+    this.solanaAddress = addresses.solana;
+    this.expiresAt = Date.now() + this.durationMs;
+    if (this.timeoutId) clearTimeout(this.timeoutId);
+    this.timeoutId = setTimeout(() => {
+      this.end();
+      this.events.emit("session-expired");
+    }, this.durationMs);
+    this.events.emit("session-started");
+  }
+  end() {
+    void this.tee?.closeSession();
+    this.tee = null;
+    this.evmAddress = null;
+    this.solanaAddress = null;
+    this.expiresAt = null;
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+  isActive() {
+    return this.tee !== null && Date.now() < (this.expiresAt ?? 0);
+  }
+  expiresAtTimestamp() {
+    return this.expiresAt;
+  }
+  requireActive() {
+    if (!this.isActive()) throw new UnlockRequiredError();
+    return this.tee;
+  }
+  addresses() {
+    if (!this.evmAddress || !this.solanaAddress) return null;
+    return { evm: this.evmAddress, solana: this.solanaAddress };
+  }
+};
+
+// src/social/crypto/shares.ts
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { split, combine } from "shamir-secret-sharing";
+function generateRandomBytes(n) {
+  return crypto.getRandomValues(new Uint8Array(n));
+}
+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 };
+}
+
+// src/social/crypto/wrap.ts
+function buf(u) {
+  return u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
+}
+async function importAesKey(rawKey) {
+  return crypto.subtle.importKey(
+    "raw",
+    buf(rawKey),
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function aesGcmEncrypt(key, plaintext, iv) {
+  const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv: buf(iv) }, key, buf(plaintext));
+  return new Uint8Array(ct);
+}
+async function aesGcmDecrypt(key, ciphertext, iv) {
+  const pt = await crypto.subtle.decrypt({ name: "AES-GCM", iv: buf(iv) }, key, buf(ciphertext));
+  return new Uint8Array(pt);
+}
+
+// src/social/crypto/pin.ts
+var PBKDF2_ITERATIONS = 6e5;
+function buf2(u) {
+  return u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
+}
+async function deriveKeyFromPin(pin, salt) {
+  const pinBytes = new TextEncoder().encode(pin);
+  const base = await crypto.subtle.importKey("raw", buf2(pinBytes), "PBKDF2", false, ["deriveKey"]);
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt: buf2(salt), iterations: PBKDF2_ITERATIONS, hash: "SHA-256" },
+    base,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+function validatePin(pin) {
+  if (!/^\d{4,8}$/.test(pin)) throw new Error("PIN must be 4\u20138 digits");
+}
+
+// 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);
+}
+function isPasskeySupported() {
+  return typeof window !== "undefined" && !!window.PublicKeyCredential && "isUserVerifyingPlatformAuthenticatorAvailable" in window.PublicKeyCredential;
+}
+async function registerPasskey(opts) {
+  let response;
+  try {
+    response = await startRegistration({ optionsJSON: opts.optionsJSON });
+  } catch (e) {
+    if (e.name === "NotAllowedError") throw new UserCancelledError();
+    throw e;
+  }
+  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));
+  let cred;
+  try {
+    cred = await navigator.credentials.get({
+      publicKey: {
+        challenge: buf3(challenge),
+        rpId: opts.rpId,
+        allowCredentials: [{ id: buf3(opts.credentialId), type: "public-key" }],
+        userVerification: "required",
+        extensions: { prf: { eval: { first: buf3(opts.prfSalt) } } }
+      }
+    });
+  } catch (e) {
+    if (e.name === "NotAllowedError") throw new UserCancelledError();
+    throw e;
+  }
+  const ext = cred.getClientExtensionResults();
+  const prfResults = ext?.prf?.results;
+  if (!prfResults?.first) throw new WebAuthnNotSupportedError();
+  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);
+}
+async function verifyEmailCode(api, email, code) {
+  return api.authEmailVerify(email, code);
+}
+
+// src/social/signers/evm.ts
+import { keccak256, Transaction, resolveProperties } from "ethers";
+async function signEvmTransaction(tee, chain, tx) {
+  const resolved = await resolveProperties(tx);
+  const unsigned = Transaction.from(resolved).unsignedSerialized;
+  const payload = unsigned.startsWith("0x") ? unsigned.slice(2) : unsigned;
+  const txHash = keccak256("0x" + payload);
+  return tee.sign({ chain, kind: "transaction", payload, txHash });
+}
+async function signEvmMessage(tee, chain, message) {
+  return tee.sign({ chain, kind: "message", payload: message });
+}
+
+// src/social/signers/solana.ts
+import { VersionedTransaction as VTx } from "@solana/web3.js";
+function b64(bytes) {
+  let s = "";
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s);
+}
+function unb64(s) {
+  return Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
+}
+async function signSolanaTransaction(tee, chain, tx) {
+  const bytes = tx instanceof VTx ? tx.serialize() : tx.serialize({ requireAllSignatures: false });
+  const signed = await tee.sign({ chain, kind: "transaction", payload: b64(bytes) });
+  return unb64(signed);
+}
+async function signSolanaMessage(tee, chain, message) {
+  const sig = await tee.sign({ chain, kind: "message", payload: b64(message) });
+  return unb64(sig);
+}
+
+// src/social/recovery/wrappedShareBackup.ts
+async function fetchWrappedShareBackup(api, jwt) {
+  return api.getRecoveryBackup(jwt);
+}
+
+// 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 unb642(s) {
+  return Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
+}
+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) {
+    input.onProgress?.({ type: "passkey-attempt" });
+    try {
+      const prfOutput = await getPrfOutput({
+        rpId: input.rpId,
+        credentialId: backup.credentialId,
+        prfSalt: backup.prfSalt
+      });
+      const wrappingKey = await importAesKey(prfOutput);
+      const deviceShare = await aesGcmDecrypt(
+        wrappingKey,
+        backup.wrappedDeviceShare,
+        backup.iv
+      );
+      await input.storage.putShare({
+        userId: input.userId,
+        wrappedDeviceShare: backup.wrappedDeviceShare,
+        iv: backup.iv,
+        unlockMethod: "passkey",
+        credentialId: backup.credentialId,
+        prfSalt: backup.prfSalt,
+        version: 1
+      });
+      return deviceShare;
+    } catch (e) {
+      input.onProgress?.({
+        type: "passkey-failed",
+        reason: e instanceof Error ? e.message : "unknown"
+      });
+    }
+  }
+  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);
+  let result;
+  try {
+    result = await tee.recoverWithShare(input.jwt, recoveryShare);
+  } finally {
+    zeroize(recoveryShare);
+  }
+  input.onProgress?.({ type: "rotated", shareSetVersion: result.shareSetVersion });
+  await input.onNewRecoveryShare?.(result.recoveryShare, result.shareSetVersion);
+  zeroize(result.recoveryShare);
+  return result.deviceShare;
+}
+
+// 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 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
+var DEFAULT_API_BASE = "https://backend.decane.app";
+var DEFAULT_TEE_URL = "https://4405742df08d19abc549a05ade2a7154d98bd87f-8443.dstack-pha-prod9.phala.network";
+var DEFAULT_SESSION_MINUTES = 30;
+var DEFAULT_RPCS = {
+  "evm:1": "https://ethereum.publicnode.com",
+  "evm:137": "https://polygon.publicnode.com",
+  "evm:8453": "https://base.publicnode.com",
+  "evm:10": "https://optimism.publicnode.com",
+  "evm:42161": "https://arbitrum-one.publicnode.com",
+  "evm:56": "https://bsc.publicnode.com",
+  "evm:11155111": "https://ethereum-sepolia.publicnode.com",
+  "evm:84532": "https://base-sepolia.publicnode.com",
+  "evm:31337": "http://localhost:8545"
+};
+function makePersistKey(apiKey) {
+  return `decane:social:${apiKey.slice(0, 20)}`;
+}
+function loadPersisted(key) {
+  try {
+    const raw = typeof localStorage !== "undefined" ? localStorage.getItem(key) : null;
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function savePersisted(key, state) {
+  try {
+    localStorage.setItem(key, JSON.stringify(state));
+  } catch {
+  }
+}
+function clearPersisted(key) {
+  try {
+    localStorage.removeItem(key);
+  } catch {
+  }
+}
+async function createDecaneConnect(config) {
+  if (!config.apiKey) throw new Error("decane-connect-kit: apiKey is required");
+  if (!config.chains?.length)
+    throw new Error("decane-connect-kit: at least one chain is required");
+  const baseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE;
+  const durationMs = (config.sessionDurationMinutes ?? DEFAULT_SESSION_MINUTES) * 6e4;
+  const rpId = config.rpId ?? (typeof window !== "undefined" ? window.location.hostname : "localhost");
+  const rpName = config.rpName ?? "Decane Connect";
+  const PERSIST_KEY = makePersistKey(config.apiKey);
+  const teeUrl = config.teeUrl ?? DEFAULT_TEE_URL;
+  const events = new EventEmitter();
+  const api = new ApiClient(baseUrl, config.apiKey);
+  const storage = new Storage();
+  const session = new SessionManager(events, durationMs, teeUrl);
+  let auth = null;
+  let persisted = loadPersisted(PERSIST_KEY);
+  async function pinSetup() {
+    if (!config.promptPin) throw new PromptPinNotConfiguredError();
+    const pin = await config.promptPin();
+    validatePin(pin);
+    const pinSalt = generateRandomBytes(32);
+    const wrappingKey = await deriveKeyFromPin(pin, pinSalt);
+    return {
+      wrappingKey,
+      meta: {
+        unlockMethod: "pin",
+        pinSalt: bufferToB64u(pinSalt),
+        pinIterations: 6e5
+      }
+    };
+  }
+  async function getWrappingKey(stored) {
+    if (stored.unlockMethod === "passkey") {
+      const prfOutput = await getPrfOutput({
+        rpId,
+        credentialId: stored.credentialId,
+        prfSalt: stored.prfSalt
+      });
+      return importAesKey(prfOutput);
+    }
+    if (!config.promptPin) throw new PromptPinNotConfiguredError();
+    const pin = await config.promptPin();
+    return deriveKeyFromPin(pin, stored.pinSalt);
+  }
+  async function registerPasskeyAndBackup(userId, jwt, deviceShare) {
+    if (!isPasskeySupported()) return;
+    const prfSalt = generateRandomBytes(32);
+    let credentialId;
+    let prfOutput;
+    try {
+      const result = await registerWebAuthnCredential({ api, jwt, rpId, rpName, prfSalt });
+      credentialId = result.credentialId;
+      prfOutput = result.prfOutput;
+    } catch (e) {
+      console.warn("decane-connect-kit: passkey provisioning after recovery failed; user can set this up later.", e);
+      return;
+    }
+    if (!prfOutput) return;
+    const wrappingKey = await importAesKey(prfOutput);
+    const iv = generateRandomBytes(12);
+    const wrappedDeviceShare = await aesGcmEncrypt(wrappingKey, deviceShare, iv);
+    await storage.putShare({
+      userId,
+      wrappedDeviceShare,
+      iv,
+      unlockMethod: "passkey",
+      credentialId,
+      prfSalt,
+      version: 1
+    });
+    try {
+      await api.putRecoveryBackup(jwt, {
+        wrappedDeviceShare,
+        iv,
+        unlockMethod: "passkey",
+        credentialId,
+        prfSalt
+      });
+    } catch (e) {
+      console.warn("decane-connect-kit: wrapped share backup upload failed; user can retry from settings.", e);
+    }
+  }
+  async function firstTimeSetup(userId, jwt) {
+    let unlockMethod;
+    let wrappingKey;
+    let meta = {};
+    if (isPasskeySupported()) {
+      const prfSalt = generateRandomBytes(32);
+      try {
+        const { credentialId, prfOutput } = await registerWebAuthnCredential({ api, jwt, rpId, rpName, prfSalt });
+        if (prfOutput) {
+          unlockMethod = "passkey";
+          wrappingKey = await importAesKey(prfOutput);
+          meta = {
+            unlockMethod: "passkey",
+            credentialId: bufferToB64u(credentialId),
+            prfSalt: bufferToB64u(prfSalt)
+          };
+        } else {
+          ({ wrappingKey, meta } = await pinSetup());
+          unlockMethod = "pin";
+        }
+      } catch (e) {
+        if (e.name === "UserCancelledError")
+          throw new UserCancelledError();
+        ({ wrappingKey, meta } = await pinSetup());
+        unlockMethod = "pin";
+      }
+    } else {
+      ({ wrappingKey, meta } = await pinSetup());
+      unlockMethod = "pin";
+    }
+    const master = generateMaster();
+    let shareSet;
+    let evmAddress;
+    let solanaAddress;
+    try {
+      evmAddress = new Wallet(toHex(master)).address;
+      solanaAddress = Keypair.fromSeed(master).publicKey.toBase58();
+      shareSet = await splitMaster(master, 1);
+    } finally {
+      zeroize(master);
+    }
+    const iv = generateRandomBytes(12);
+    const wrappedDeviceShare = await aesGcmEncrypt(
+      wrappingKey,
+      shareSet.device,
+      iv
+    );
+    await storage.putShare({
+      userId,
+      wrappedDeviceShare,
+      iv,
+      unlockMethod,
+      credentialId: meta.credentialId ? b64uToBuffer(meta.credentialId) : void 0,
+      prfSalt: meta.prfSalt ? b64uToBuffer(meta.prfSalt) : void 0,
+      pinSalt: meta.pinSalt ? b64uToBuffer(meta.pinSalt) : void 0,
+      pinIterations: meta.pinIterations,
+      version: 1
+    });
+    const serverIv = generateRandomBytes(12);
+    await api.putShare(jwt, {
+      ciphertext: shareSet.server,
+      iv: serverIv,
+      wrappedShareMeta: {
+        unlockMethod
+        // credential IDs, prfSalt, pinSalt stay on-device — never sent to server
+      },
+      evmAddress,
+      solanaAddress
+    });
+    zeroize(shareSet.server);
+    const addresses = { evm: evmAddress, solana: solanaAddress };
+    if (unlockMethod === "passkey" && meta.credentialId && meta.prfSalt) {
+      try {
+        await api.putRecoveryBackup(jwt, {
+          wrappedDeviceShare,
+          iv,
+          unlockMethod: "passkey",
+          credentialId: b64uToBuffer(meta.credentialId),
+          prfSalt: b64uToBuffer(meta.prfSalt)
+        });
+      } catch (e) {
+        console.warn("decane-connect-kit: wrapped share backup failed; user can retry from settings.", e);
+      }
+    }
+    await session.start(shareSet.device, jwt, addresses);
+    zeroize(shareSet.device);
+    if (config.offerRecoveryAtSignup !== false && config.onRecoveryShareOffer) {
+      try {
+        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 share offer failed or was skipped.", e);
+      }
+    }
+    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 stored = await storage.getShare(userId);
+    let deviceShare;
+    if (!stored) {
+      deviceShare = await recoverDeviceShare({
+        userId,
+        jwt,
+        rpId,
+        teeUrl,
+        api,
+        storage,
+        onProgress: config.onRecoveryProgress,
+        promptForRecoveryFile: config.promptForRecoveryFile,
+        onNewRecoveryShare: async (recoveryShare, shareSetVersion) => {
+          if (!config.onRecoveryRotated) {
+            console.warn("decane-connect-kit: share set rotated after recovery, but no onRecoveryRotated callback is configured \u2014 the user has no way to save a new recovery-share file.");
+            return;
+          }
+          const { password, passwordHint } = await config.onRecoveryRotated({ evmAddress: addresses.evm, solanaAddress: addresses.solana });
+          const file = await buildRecoveryShareFile(recoveryShare, password, addresses, shareSetVersion, passwordHint);
+          await config.onRecoveryFileReady?.(file, recoveryShareFileName(addresses.evm));
+          await api.markRecoveryShareSaved(jwt);
+        }
+      });
+      if (!await storage.getShare(userId) && isPasskeySupported()) {
+        await registerPasskeyAndBackup(userId, jwt, deviceShare);
+      }
+    } else {
+      const wrappingKey = await getWrappingKey(stored);
+      try {
+        deviceShare = await aesGcmDecrypt(
+          wrappingKey,
+          stored.wrappedDeviceShare,
+          stored.iv
+        );
+      } catch {
+        throw stored.unlockMethod === "pin" ? new InvalidPinError() : new ShareCorruptedError();
+      }
+    }
+    await session.start(deviceShare, jwt, addresses);
+    zeroize(deviceShare);
+    return addresses;
+  }
+  async function handleAuthResult(result) {
+    let addresses;
+    if (!result.hasShare) {
+      addresses = await firstTimeSetup(result.userId, result.jwt);
+    } else {
+      addresses = await returningUserUnlock(result.userId, result.jwt);
+    }
+    auth = { jwt: result.jwt, userId: result.userId, addresses };
+    persisted = { userId: result.userId, addresses };
+    savePersisted(PERSIST_KEY, persisted);
+    events.emit("connected");
+    return { addresses, isNewUser: result.isNewUser };
+  }
+  const client = {
+    async connect() {
+      if (auth && session.isActive()) {
+        return { addresses: auth.addresses, isNewUser: false };
+      }
+      const method = config.authMethods[0];
+      if (!method) throw new CallSequenceError("No authMethods configured");
+      if (method === "google") return client.connectWithGoogle();
+      if (method === "email")
+        throw new CallSequenceError(
+          "Use connectWithEmail(email) for email auth"
+        );
+      throw new CallSequenceError(`Unknown auth method: ${method}`);
+    },
+    async connectWithGoogle() {
+      const params = new URLSearchParams(window.location.search);
+      const decaneJwt = params.get("decane_jwt");
+      const decaneError = params.get("decane_error");
+      if (decaneError) {
+        window.history.replaceState({}, "", window.location.pathname);
+        throw new CallSequenceError(`Google sign-in failed: ${decaneError}`);
+      }
+      if (decaneJwt) {
+        const result = {
+          jwt: decaneJwt,
+          userId: params.get("decane_user_id") ?? "",
+          isNewUser: params.get("decane_is_new_user") === "true",
+          hasShare: params.get("decane_has_share") === "true"
+        };
+        window.history.replaceState({}, "", window.location.pathname);
+        return handleAuthResult(result);
+      }
+      const { url } = await api.getGoogleInitUrl();
+      window.location.href = url;
+      return new Promise(() => {
+      });
+    },
+    async connectWithEmail(email) {
+      await startEmailAuth(api, email);
+      return { codeRequired: true };
+    },
+    async verifyEmailCode(email, code) {
+      const result = await verifyEmailCode(api, email, code);
+      return handleAuthResult(result);
+    },
+    async unlock() {
+      if (!auth)
+        throw new CallSequenceError("Not connected \u2014 call connect() first");
+      if (session.isActive()) return;
+      await returningUserUnlock(auth.userId, auth.jwt);
+    },
+    isUnlocked() {
+      return session.isActive();
+    },
+    sessionExpiresAt() {
+      return session.expiresAtTimestamp();
+    },
+    async signMessage(req) {
+      const tee = session.requireActive();
+      if (req.chain.startsWith("evm:")) {
+        return signEvmMessage(tee, req.chain, req.message);
+      }
+      if (req.chain.startsWith("solana:")) {
+        const msg = typeof req.message === "string" ? new TextEncoder().encode(req.message) : req.message;
+        const sig = await signSolanaMessage(tee, req.chain, msg);
+        return bufferToB64u(sig);
+      }
+      throw new CallSequenceError(`Unsupported chain: ${req.chain}`);
+    },
+    async sendTransaction(req) {
+      const tee = session.requireActive();
+      if (!req.chain.startsWith("evm:")) {
+        throw new CallSequenceError(
+          "sendTransaction is EVM-only. Use signSolanaTransaction for Solana."
+        );
+      }
+      if (!auth?.addresses.evm) {
+        throw new CallSequenceError("Not connected");
+      }
+      const evmAddr = auth.addresses.evm;
+      const rpcUrl = config.rpcUrls?.[req.chain] ?? DEFAULT_RPCS[req.chain];
+      if (!rpcUrl) {
+        throw new CallSequenceError(
+          `No RPC URL for ${req.chain}. Pass rpcUrls: { '${req.chain}': 'https://...' } in social config.`
+        );
+      }
+      const { JsonRpcProvider } = await import("ethers");
+      const provider = new JsonRpcProvider(rpcUrl);
+      const chainId = parseInt(req.chain.slice(4), 10);
+      const [nonce, feeData] = await Promise.all([
+        provider.getTransactionCount(evmAddr, "pending"),
+        provider.getFeeData()
+      ]);
+      const gasLimit = req.gasLimit ?? await provider.estimateGas({
+        from: evmAddr,
+        to: req.to,
+        value: req.value ?? 0n,
+        data: req.data
+      });
+      const tx = {
+        to: req.to,
+        value: req.value ?? 0n,
+        data: req.data,
+        gasLimit,
+        chainId,
+        nonce,
+        // EIP-1559 fees — fall back to legacy gasPrice if unavailable
+        ...feeData.maxFeePerGas != null ? {
+          maxFeePerGas: feeData.maxFeePerGas,
+          maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ?? 0n
+        } : { gasPrice: req.gasPrice ?? feeData.gasPrice ?? void 0 }
+      };
+      const signedTx = await signEvmTransaction(tee, req.chain, tx);
+      const txResponse = await provider.broadcastTransaction(signedTx);
+      return txResponse.hash;
+    },
+    async signSolanaTransaction(serializedTx) {
+      const tee = session.requireActive();
+      let tx;
+      try {
+        tx = VersionedTransaction.deserialize(serializedTx);
+      } catch {
+        tx = Transaction2.from(serializedTx);
+      }
+      const solChain = config.chains.find((c) => c.startsWith("solana:")) ?? "solana:mainnet";
+      return signSolanaTransaction(tee, solChain, tx);
+    },
+    async disconnect() {
+      session.end();
+      if (auth?.jwt) {
+        await api.revoke(auth.jwt).catch(() => {
+        });
+      }
+      auth = null;
+      persisted = null;
+      clearPersisted(PERSIST_KEY);
+      events.emit("disconnected");
+    },
+    getAddresses() {
+      return auth?.addresses ?? persisted?.addresses ?? null;
+    },
+    async rotateShares(opts) {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      const tee = session.requireActive();
+      const result = await tee.rotateShares(auth.jwt);
+      try {
+        const file = await buildRecoveryShareFile(
+          result.recoveryShare,
+          opts.password,
+          auth.addresses,
+          result.shareSetVersion,
+          opts.passwordHint
+        );
+        await api.markRecoveryShareSaved(auth.jwt);
+        return file;
+      } finally {
+        zeroize(result.deviceShare);
+        zeroize(result.recoveryShare);
+      }
+    },
+    async exportPortableBackup(opts) {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      const tee = session.requireActive();
+      const result = await tee.exportPortableBackup(auth.jwt);
+      try {
+        return await buildPortableBackup(
+          result.deviceShare,
+          result.recoveryShare,
+          opts.password,
+          auth.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");
+      return api.hasRecoveryBackup(auth.jwt);
+    },
+    async deleteBackup() {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      await api.deleteRecoveryBackup(auth.jwt);
+    },
+    on: events.on.bind(events),
+    off: events.off.bind(events)
+  };
+  return client;
+}
+function bufferToB64u(buf6) {
+  return btoa(String.fromCharCode(...buf6)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function b64uToBuffer(b64u) {
+  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("");
+}
+
+// src/social/index.ts
+init_errors();
+
+// src/ui/WalletSelector.tsx
+import React2, { useEffect, useCallback, useState } from "react";
+import { createPortal } from "react-dom";
+
+// src/ui/styles.ts
+var tokens = {
+  // ── Gold palette ──────────────────────────────────────────────────────────
+  gold: {
+    50: "#FFFDF0",
+    100: "#FFF8D6",
+    200: "#FFEF99",
+    300: "#FFE04D",
+    400: "#F5C800",
+    // primary gold — buttons, accents
+    500: "#D4A800",
+    // darker gold — hover states
+    600: "#A37F00",
+    // deep gold — borders, active
+    700: "#7A5E00",
+    800: "#4D3B00",
+    900: "#261D00"
+  },
+  // ── Black / dark palette ──────────────────────────────────────────────────
+  black: {
+    0: "#FFFFFF",
+    50: "#F9F9F7",
+    100: "#F0EFEB",
+    200: "#DDDCDA",
+    300: "#BDBBB8",
+    400: "#8A8884",
+    500: "#5C5A57",
+    600: "#3D3C39",
+    700: "#2A2927",
+    800: "#1A1917",
+    900: "#0D0D0B",
+    950: "#070706"
+  },
+  // ── Semantic tokens — light mode ──────────────────────────────────────────
+  light: {
+    bg: "#FFFFFF",
+    bgOverlay: "rgba(0, 0, 0, 0.55)",
+    surface: "#F9F9F7",
+    surfaceHover: "#F0EFEB",
+    border: "#DDDCDA",
+    borderAccent: "#F5C800",
+    text: "#0D0D0B",
+    textSecondary: "#5C5A57",
+    textMuted: "#8A8884",
+    accent: "#F5C800",
+    accentHover: "#D4A800",
+    accentText: "#0D0D0B",
+    badgeEvm: "#1A1917",
+    badgeEvmText: "#F5C800",
+    badgeSolana: "#F5C800",
+    badgeSolanaText: "#0D0D0B",
+    danger: "#CC3300"
+  },
+  // ── Semantic tokens — dark mode ───────────────────────────────────────────
+  dark: {
+    bg: "#0D0D0B",
+    bgOverlay: "rgba(0, 0, 0, 0.75)",
+    surface: "#1A1917",
+    surfaceHover: "#2A2927",
+    border: "#3D3C39",
+    borderAccent: "#F5C800",
+    text: "#F9F9F7",
+    textSecondary: "#BDBBB8",
+    textMuted: "#8A8884",
+    accent: "#F5C800",
+    accentHover: "#FFE04D",
+    accentText: "#0D0D0B",
+    badgeEvm: "#F5C800",
+    badgeEvmText: "#0D0D0B",
+    badgeSolana: "#1A1917",
+    badgeSolanaText: "#F5C800",
+    danger: "#FF5533"
+  }
+};
+var FONT_SANS = "'Plus Jakarta Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
+var FONT_MONO = "'JetBrains Mono', 'Fira Code', ui-monospace, monospace";
+var CSS_VARS = {
+  light: `
+    --dc-font-sans:       ${FONT_SANS};
+    --dc-font-mono:       ${FONT_MONO};
+    --dc-bg:              ${tokens.light.bg};
+    --dc-bg-overlay:      ${tokens.light.bgOverlay};
+    --dc-surface:         ${tokens.light.surface};
+    --dc-surface-hover:   ${tokens.light.surfaceHover};
+    --dc-border:          ${tokens.light.border};
+    --dc-border-accent:   ${tokens.light.borderAccent};
+    --dc-text:            ${tokens.light.text};
+    --dc-text-secondary:  ${tokens.light.textSecondary};
+    --dc-text-muted:      ${tokens.light.textMuted};
+    --dc-accent:          ${tokens.light.accent};
+    --dc-accent-hover:    ${tokens.light.accentHover};
+    --dc-accent-text:     ${tokens.light.accentText};
+    --dc-badge-evm:       ${tokens.light.badgeEvm};
+    --dc-badge-evm-text:  ${tokens.light.badgeEvmText};
+    --dc-badge-sol:       ${tokens.light.badgeSolana};
+    --dc-badge-sol-text:  ${tokens.light.badgeSolanaText};
+    --dc-danger:          ${tokens.light.danger};
+  `,
+  dark: `
+    --dc-font-sans:       ${FONT_SANS};
+    --dc-font-mono:       ${FONT_MONO};
+    --dc-bg:              ${tokens.dark.bg};
+    --dc-bg-overlay:      ${tokens.dark.bgOverlay};
+    --dc-surface:         ${tokens.dark.surface};
+    --dc-surface-hover:   ${tokens.dark.surfaceHover};
+    --dc-border:          ${tokens.dark.border};
+    --dc-border-accent:   ${tokens.dark.borderAccent};
+    --dc-text:            ${tokens.dark.text};
+    --dc-text-secondary:  ${tokens.dark.textSecondary};
+    --dc-text-muted:      ${tokens.dark.textMuted};
+    --dc-accent:          ${tokens.dark.accent};
+    --dc-accent-hover:    ${tokens.dark.accentHover};
+    --dc-accent-text:     ${tokens.dark.accentText};
+    --dc-badge-evm:       ${tokens.dark.badgeEvm};
+    --dc-badge-evm-text:  ${tokens.dark.badgeEvmText};
+    --dc-badge-sol:       ${tokens.dark.badgeSolana};
+    --dc-badge-sol-text:  ${tokens.dark.badgeSolanaText};
+    --dc-danger:          ${tokens.dark.danger};
+  `
+};
+
+// src/ui/icons.tsx
+import React from "react";
+function WalletIcon({ src, name, size = 36 }) {
+  if (src) {
+    return /* @__PURE__ */ React.createElement(
+      "img",
+      {
+        src,
+        alt: name,
+        width: size,
+        height: size,
+        style: { borderRadius: size * 0.25, objectFit: "cover", flexShrink: 0 }
+      }
+    );
+  }
+  const initial = name.charAt(0).toUpperCase();
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        width: size,
+        height: size,
+        borderRadius: size * 0.25,
+        background: "linear-gradient(135deg, var(--dc-surface-hover), var(--dc-surface-active, var(--dc-surface-hover)))",
+        border: "1px solid var(--dc-border)",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontSize: size * 0.38,
         fontWeight: 800,
         color: "var(--dc-accent)",
         flexShrink: 0,
@@ -2083,17 +3627,33 @@ function ChainOption({ label, description, badges, onClick }) {
     /* @__PURE__ */ React2.createElement("span", { style: { fontSize: 11, color: "var(--dc-text-muted)", lineHeight: 1.4 } }, description)
   );
 }
+function hasSocialMode(mode) {
+  return mode === "all" || mode === "social" || mode === "evm+social" || mode === "solana+social" || mode === "tron+social" || mode === "evm+tron+social";
+}
 function WalletSelector({
   provider,
   open,
   onClose,
   onConnect,
   theme = "auto",
-  networks = "all"
+  networks = "all",
+  mode = "wallets",
+  socialAuthMethods = ["google", "email"],
+  onGoogleSignIn,
+  onEmailStart,
+  onEmailVerify
 }) {
+  const showSocial = hasSocialMode(mode);
+  const showWallets = mode !== "social";
+  const [view, setView] = useState(showWallets ? "wallets" : "social");
   const [search, setSearch] = useState("");
   const [filter, setFilter] = useState("all");
   const [pendingWallet, setPendingWallet] = useState(null);
+  const [emailStep, setEmailStep] = useState("input");
+  const [emailVal, setEmailVal] = useState("");
+  const [codeVal, setCodeVal] = useState("");
+  const [socialLoad, setSocialLoad] = useState(false);
+  const [socialErr, setSocialErr] = useState("");
   useEffect(() => {
     if (!open) return;
     injectFont();
@@ -2109,12 +3669,55 @@ function WalletSelector({
       setSearch("");
       setFilter("all");
       setPendingWallet(null);
+      setView(showWallets ? "wallets" : "social");
+      setEmailStep("input");
+      setEmailVal("");
+      setCodeVal("");
+      setSocialErr("");
       return;
     }
     return () => {
       document.getElementById("decane-tokens")?.remove();
     };
-  }, [open]);
+  }, [open, showWallets]);
+  async function handleGoogleClick() {
+    if (!onGoogleSignIn) return;
+    setSocialLoad(true);
+    setSocialErr("");
+    try {
+      await onGoogleSignIn();
+    } catch (e) {
+      setSocialErr(e.message);
+      setSocialLoad(false);
+    }
+  }
+  async function handleEmailStart(e) {
+    e.preventDefault();
+    if (!onEmailStart) return;
+    setSocialLoad(true);
+    setSocialErr("");
+    try {
+      await onEmailStart(emailVal);
+      setEmailStep("code");
+    } catch (e2) {
+      setSocialErr(e2.message);
+    } finally {
+      setSocialLoad(false);
+    }
+  }
+  async function handleEmailVerify(e) {
+    e.preventDefault();
+    if (!onEmailVerify) return;
+    setSocialLoad(true);
+    setSocialErr("");
+    try {
+      await onEmailVerify(emailVal, codeVal);
+    } catch (e2) {
+      setSocialErr(e2.message);
+    } finally {
+      setSocialLoad(false);
+    }
+  }
   const handleKey = useCallback(
     (e) => {
       if (e.key === "Escape") {
@@ -2327,8 +3930,8 @@ function WalletSelector({
           }
         )))
       ) : (
-        /* ── Wallet list step ────────────────────────────────────────── */
-        /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement("div", { style: { padding: "18px 20px 0" } }, /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", alignItems: "flex-start", justifyContent: "space-between", marginBottom: 14 } }, /* @__PURE__ */ React2.createElement("div", null, /* @__PURE__ */ React2.createElement("h2", { style: { margin: 0, fontSize: 17, fontWeight: 800, color: "var(--dc-text)", letterSpacing: "-0.02em", lineHeight: 1.2 } }, "Connect wallet"), networkWallets.length > 0 && /* @__PURE__ */ React2.createElement("p", { style: { margin: "3px 0 0", fontSize: 12, color: "var(--dc-text-muted)" } }, networkWallets.length, " wallet", networkWallets.length !== 1 ? "s" : "", " detected")), /* @__PURE__ */ React2.createElement(
+        /* ── Wallet list / Social sign-in ────────────────────────────── */
+        /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement("div", { style: { padding: "18px 20px 0" } }, /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", alignItems: "flex-start", justifyContent: "space-between", marginBottom: 14 } }, /* @__PURE__ */ React2.createElement("div", null, /* @__PURE__ */ React2.createElement("h2", { style: { margin: 0, fontSize: 17, fontWeight: 800, color: "var(--dc-text)", letterSpacing: "-0.02em", lineHeight: 1.2 } }, view === "social" ? "Sign in" : "Connect wallet"), view === "wallets" && networkWallets.length > 0 && /* @__PURE__ */ React2.createElement("p", { style: { margin: "3px 0 0", fontSize: 12, color: "var(--dc-text-muted)" } }, networkWallets.length, " wallet", networkWallets.length !== 1 ? "s" : "", " detected")), /* @__PURE__ */ React2.createElement(
           "button",
           {
             onClick: onClose,
@@ -2359,7 +3962,28 @@ function WalletSelector({
             }
           },
           /* @__PURE__ */ React2.createElement("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none" }, /* @__PURE__ */ React2.createElement("path", { d: "M1.5 1.5L10.5 10.5M10.5 1.5L1.5 10.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round" }))
-        )), /* @__PURE__ */ React2.createElement("div", { style: { position: "relative", marginBottom: 10 } }, /* @__PURE__ */ React2.createElement(
+        )), showWallets && showSocial && /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 4, marginBottom: 14, background: "var(--dc-surface)", borderRadius: 10, padding: 3 } }, ["wallets", "social"].map((v) => /* @__PURE__ */ React2.createElement(
+          "button",
+          {
+            key: v,
+            onClick: () => setView(v),
+            style: {
+              flex: 1,
+              padding: "7px 0",
+              borderRadius: 8,
+              border: "none",
+              background: view === v ? "var(--dc-bg)" : "transparent",
+              color: view === v ? "var(--dc-text)" : "var(--dc-text-muted)",
+              fontSize: 13,
+              fontWeight: view === v ? 700 : 500,
+              cursor: "pointer",
+              fontFamily: "inherit",
+              boxShadow: view === v ? "0 1px 4px rgba(0,0,0,0.2)" : "none",
+              transition: "all 0.15s"
+            }
+          },
+          v === "wallets" ? "Wallet" : "Sign in"
+        ))), view === "wallets" && networks === "all" && /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 4, marginBottom: 10 } }, /* @__PURE__ */ React2.createElement(FilterTab, { label: "All", active: filter === "all", onClick: () => setFilter("all") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "EVM", active: filter === "evm", onClick: () => setFilter("evm") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "Solana", active: filter === "solana", onClick: () => setFilter("solana") }), provider.tronWallets && provider.tronWallets.length > 0 && /* @__PURE__ */ React2.createElement(FilterTab, { label: "Tron", active: filter === "tron", onClick: () => setFilter("tron") }), provider.bitcoinWallets && provider.bitcoinWallets.length > 0 && /* @__PURE__ */ React2.createElement(FilterTab, { label: "Bitcoin", active: filter === "bitcoin", onClick: () => setFilter("bitcoin") })), view === "wallets" && /* @__PURE__ */ React2.createElement("div", { style: { position: "relative", marginBottom: 10 } }, /* @__PURE__ */ React2.createElement(
           "svg",
           {
             width: "14",
@@ -2397,52 +4021,628 @@ function WalletSelector({
               e.currentTarget.style.borderColor = "var(--dc-border)";
             }
           }
-        )), networks === "all" && /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 4, marginBottom: 10 } }, /* @__PURE__ */ React2.createElement(FilterTab, { label: "All", active: filter === "all", onClick: () => setFilter("all") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "EVM", active: filter === "evm", onClick: () => setFilter("evm") }), /* @__PURE__ */ React2.createElement(FilterTab, { label: "Solana", active: filter === "solana", onClick: () => setFilter("solana") }), provider.tronWallets && provider.tronWallets.length > 0 && /* @__PURE__ */ React2.createElement(FilterTab, { label: "Tron", active: filter === "tron", onClick: () => setFilter("tron") }), provider.bitcoinWallets && provider.bitcoinWallets.length > 0 && /* @__PURE__ */ React2.createElement(FilterTab, { label: "Bitcoin", active: filter === "bitcoin", onClick: () => setFilter("bitcoin") }))), /* @__PURE__ */ React2.createElement("div", { style: { overflowY: "auto", flex: 1, padding: "0 12px 20px" } }, filtered.length > 0 ? /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 2 } }, filtered.map((w) => /* @__PURE__ */ React2.createElement(WalletRow, { key: w.id, wallet: w, onClick: () => handleWalletClick(w) }))) : /* @__PURE__ */ React2.createElement("div", { style: { textAlign: "center", padding: "32px 16px", color: "var(--dc-text-muted)", fontSize: 13 } }, q ? `No wallets matching "${q}"` : "No wallets detected")), /* @__PURE__ */ React2.createElement("div", { style: { padding: "10px 20px 14px", borderTop: "1px solid var(--dc-border)", textAlign: "center", fontSize: 11, color: "var(--dc-text-muted)" } }, "Don't see your wallet? Make sure it's installed and unlocked"))
+        ))), view === "social" && /* @__PURE__ */ React2.createElement("div", { style: { padding: "4px 20px 24px", display: "flex", flexDirection: "column", gap: 10 } }, socialErr && /* @__PURE__ */ React2.createElement("div", { style: { background: "rgba(204,51,0,0.1)", border: "1px solid var(--dc-danger)", borderRadius: 8, padding: "9px 12px", fontSize: 12, color: "var(--dc-danger)" } }, socialErr), socialAuthMethods.includes("google") && /* @__PURE__ */ React2.createElement(
+          "button",
+          {
+            onClick: handleGoogleClick,
+            disabled: socialLoad,
+            style: {
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              gap: 10,
+              width: "100%",
+              padding: "11px 16px",
+              background: "var(--dc-surface)",
+              border: "1px solid var(--dc-border)",
+              borderRadius: 10,
+              cursor: socialLoad ? "not-allowed" : "pointer",
+              fontSize: 14,
+              fontWeight: 600,
+              color: "var(--dc-text)",
+              fontFamily: "inherit",
+              transition: "border-color 0.12s, background 0.12s",
+              opacity: socialLoad ? 0.6 : 1
+            },
+            onMouseEnter: (e) => {
+              if (!socialLoad) e.currentTarget.style.borderColor = "var(--dc-border-accent)";
+            },
+            onMouseLeave: (e) => {
+              e.currentTarget.style.borderColor = "var(--dc-border)";
+            }
+          },
+          /* @__PURE__ */ React2.createElement("svg", { width: "18", height: "18", viewBox: "0 0 18 18", fill: "none" }, /* @__PURE__ */ React2.createElement("path", { d: "M17.64 9.2c0-.637-.057-1.251-.164-1.84H9v3.481h4.844c-.209 1.125-.843 2.078-1.796 2.717v2.258h2.908c1.702-1.567 2.684-3.875 2.684-6.615z", fill: "#4285F4" }), /* @__PURE__ */ React2.createElement("path", { d: "M9 18c2.43 0 4.467-.806 5.956-2.18l-2.908-2.259c-.806.54-1.837.86-3.048.86-2.344 0-4.328-1.584-5.036-3.711H.957v2.332A8.997 8.997 0 0 0 9 18z", fill: "#34A853" }), /* @__PURE__ */ React2.createElement("path", { d: "M3.964 10.71A5.41 5.41 0 0 1 3.682 9c0-.593.102-1.17.282-1.71V4.958H.957A8.996 8.996 0 0 0 0 9c0 1.452.348 2.827.957 4.042l3.007-2.332z", fill: "#FBBC05" }), /* @__PURE__ */ React2.createElement("path", { d: "M9 3.58c1.321 0 2.508.454 3.44 1.345l2.582-2.58C13.463.891 11.426 0 9 0A8.997 8.997 0 0 0 .957 4.958L3.964 6.29C4.672 4.163 6.656 3.58 9 3.58z", fill: "#EA4335" })),
+          socialLoad ? "Redirecting\u2026" : "Continue with Google"
+        ), socialAuthMethods.includes("google") && socialAuthMethods.includes("email") && /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", alignItems: "center", gap: 10 } }, /* @__PURE__ */ React2.createElement("div", { style: { flex: 1, height: 1, background: "var(--dc-border)" } }), /* @__PURE__ */ React2.createElement("span", { style: { fontSize: 11, color: "var(--dc-text-muted)", whiteSpace: "nowrap" } }, "or continue with email"), /* @__PURE__ */ React2.createElement("div", { style: { flex: 1, height: 1, background: "var(--dc-border)" } })), socialAuthMethods.includes("email") && (emailStep === "input" ? /* @__PURE__ */ React2.createElement("form", { onSubmit: handleEmailStart, style: { display: "flex", flexDirection: "column", gap: 8 } }, /* @__PURE__ */ React2.createElement(
+          "input",
+          {
+            type: "email",
+            placeholder: "your@email.com",
+            value: emailVal,
+            onChange: (e) => setEmailVal(e.target.value),
+            required: true,
+            style: {
+              width: "100%",
+              padding: "10px 12px",
+              background: "var(--dc-surface)",
+              border: "1px solid var(--dc-border)",
+              borderRadius: 10,
+              color: "var(--dc-text)",
+              fontSize: 13,
+              fontFamily: "inherit",
+              outline: "none",
+              boxSizing: "border-box"
+            },
+            onFocus: (e) => {
+              e.currentTarget.style.borderColor = "var(--dc-border-accent)";
+            },
+            onBlur: (e) => {
+              e.currentTarget.style.borderColor = "var(--dc-border)";
+            }
+          }
+        ), /* @__PURE__ */ React2.createElement(
+          "button",
+          {
+            type: "submit",
+            disabled: socialLoad || !emailVal,
+            style: {
+              width: "100%",
+              padding: "10px 16px",
+              background: "var(--dc-accent)",
+              color: "var(--dc-accent-text)",
+              border: "none",
+              borderRadius: 10,
+              fontSize: 14,
+              fontWeight: 700,
+              cursor: socialLoad ? "not-allowed" : "pointer",
+              fontFamily: "inherit",
+              opacity: socialLoad || !emailVal ? 0.6 : 1
+            }
+          },
+          socialLoad ? "Sending\u2026" : "Send code"
+        )) : /* @__PURE__ */ React2.createElement("form", { onSubmit: handleEmailVerify, style: { display: "flex", flexDirection: "column", gap: 8 } }, /* @__PURE__ */ React2.createElement("p", { style: { margin: 0, fontSize: 12, color: "var(--dc-text-muted)", textAlign: "center" } }, "Code sent to ", /* @__PURE__ */ React2.createElement("strong", { style: { color: "var(--dc-text)" } }, emailVal)), /* @__PURE__ */ React2.createElement(
+          "input",
+          {
+            type: "text",
+            placeholder: "6-digit code",
+            value: codeVal,
+            onChange: (e) => setCodeVal(e.target.value.replace(/\D/g, "").slice(0, 6)),
+            autoFocus: true,
+            required: true,
+            style: {
+              width: "100%",
+              padding: "10px 12px",
+              background: "var(--dc-surface)",
+              border: "1px solid var(--dc-border)",
+              borderRadius: 10,
+              color: "var(--dc-text)",
+              fontSize: 20,
+              fontFamily: "monospace",
+              letterSpacing: 8,
+              textAlign: "center",
+              outline: "none",
+              boxSizing: "border-box"
+            },
+            onFocus: (e) => {
+              e.currentTarget.style.borderColor = "var(--dc-border-accent)";
+            },
+            onBlur: (e) => {
+              e.currentTarget.style.borderColor = "var(--dc-border)";
+            }
+          }
+        ), /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", gap: 8 } }, /* @__PURE__ */ React2.createElement(
+          "button",
+          {
+            type: "button",
+            onClick: () => {
+              setEmailStep("input");
+              setCodeVal("");
+              setSocialErr("");
+            },
+            style: {
+              flex: 1,
+              padding: "9px 0",
+              background: "transparent",
+              border: "1px solid var(--dc-border)",
+              borderRadius: 10,
+              color: "var(--dc-text-muted)",
+              fontSize: 13,
+              cursor: "pointer",
+              fontFamily: "inherit"
+            }
+          },
+          "Back"
+        ), /* @__PURE__ */ React2.createElement(
+          "button",
+          {
+            type: "submit",
+            disabled: socialLoad || codeVal.length < 6,
+            style: {
+              flex: 2,
+              padding: "9px 0",
+              background: "var(--dc-accent)",
+              color: "var(--dc-accent-text)",
+              border: "none",
+              borderRadius: 10,
+              fontSize: 13,
+              fontWeight: 700,
+              cursor: socialLoad || codeVal.length < 6 ? "not-allowed" : "pointer",
+              fontFamily: "inherit",
+              opacity: socialLoad || codeVal.length < 6 ? 0.6 : 1
+            }
+          },
+          socialLoad ? "Verifying\u2026" : "Verify"
+        ))))), view === "wallets" && /* @__PURE__ */ React2.createElement("div", { style: { overflowY: "auto", flex: 1, padding: "0 12px 20px" } }, filtered.length > 0 ? /* @__PURE__ */ React2.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 2 } }, filtered.map((w) => /* @__PURE__ */ React2.createElement(WalletRow, { key: w.id, wallet: w, onClick: () => handleWalletClick(w) }))) : /* @__PURE__ */ React2.createElement("div", { style: { textAlign: "center", padding: "32px 16px", color: "var(--dc-text-muted)", fontSize: 13 } }, q ? `No wallets matching "${q}"` : "No wallets detected")), view === "wallets" && /* @__PURE__ */ React2.createElement("div", { style: { padding: "10px 20px 14px", borderTop: "1px solid var(--dc-border)", textAlign: "center", fontSize: 11, color: "var(--dc-text-muted)" } }, "Don't see your wallet? Make sure it's installed and unlocked"))
       )
     )
   );
   return createPortal(modal, document.body);
 }
 
+// src/ui/SocialWalletModal.tsx
+import React3, { useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
+import { createPortal as createPortal2 } from "react-dom";
+function injectTokens2(theme) {
+  const resolved = theme === "auto" ? window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light" : theme;
+  let el = document.getElementById("decane-tokens");
+  if (!el) {
+    el = document.createElement("style");
+    el.id = "decane-tokens";
+    document.head.appendChild(el);
+  }
+  el.textContent = `:root { ${CSS_VARS[resolved]} }`;
+}
+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 CopyButton({ value }) {
+  const [copied, setCopied] = useState2(false);
+  async function copy() {
+    await navigator.clipboard.writeText(value).catch(() => {
+    });
+    setCopied(true);
+    setTimeout(() => setCopied(false), 1500);
+  }
+  return /* @__PURE__ */ React3.createElement(
+    "button",
+    {
+      onClick: copy,
+      style: {
+        background: "none",
+        border: "none",
+        cursor: "pointer",
+        color: copied ? "var(--dc-accent)" : "var(--dc-text-muted)",
+        fontSize: 11,
+        fontFamily: "inherit",
+        padding: "2px 6px",
+        borderRadius: 5,
+        transition: "color 0.15s"
+      }
+    },
+    copied ? "\u2713" : "copy"
+  );
+}
+function AddressRow({ label, address }) {
+  const short = `${address.slice(0, 8)}\u2026${address.slice(-6)}`;
+  return /* @__PURE__ */ React3.createElement("div", { style: {
+    background: "var(--dc-surface)",
+    border: "1px solid var(--dc-border)",
+    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 })));
+}
+function SocialWalletModal({
+  open,
+  onClose,
+  theme = "auto",
+  socialAuth,
+  onUnlock,
+  onDisconnect
+}) {
+  const [timer, setTimer] = useState2("");
+  const [unlocking, setUnlocking] = useState2(false);
+  const [disconnecting, setDisconnecting] = useState2(false);
+  useEffect2(() => {
+    if (!open) return;
+    injectTokens2(theme);
+    if (theme !== "auto") return;
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    const h = () => injectTokens2("auto");
+    mq.addEventListener("change", h);
+    return () => mq.removeEventListener("change", h);
+  }, [open, theme]);
+  useEffect2(() => {
+    if (!socialAuth.sessionExpiresAt) {
+      setTimer("");
+      return;
+    }
+    setTimer(countdown(socialAuth.sessionExpiresAt));
+    const id = setInterval(() => setTimer(countdown(socialAuth.sessionExpiresAt)), 1e3);
+    return () => clearInterval(id);
+  }, [socialAuth.sessionExpiresAt]);
+  const handleKey = useCallback2((e) => {
+    if (e.key === "Escape") onClose();
+  }, [onClose]);
+  useEffect2(() => {
+    if (!open) return;
+    document.addEventListener("keydown", handleKey);
+    return () => document.removeEventListener("keydown", handleKey);
+  }, [open, handleKey]);
+  if (!open) return null;
+  async function handleUnlock() {
+    setUnlocking(true);
+    try {
+      await onUnlock();
+    } finally {
+      setUnlocking(false);
+    }
+  }
+  async function handleDisconnect() {
+    setDisconnecting(true);
+    try {
+      await onDisconnect();
+      onClose();
+    } finally {
+      setDisconnecting(false);
+    }
+  }
+  const modal = /* @__PURE__ */ React3.createElement(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": "Social wallet",
+      style: {
+        position: "fixed",
+        inset: 0,
+        zIndex: 9999,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        padding: 16,
+        fontFamily: "var(--dc-font-sans, system-ui, sans-serif)"
+      }
+    },
+    /* @__PURE__ */ React3.createElement(
+      "div",
+      {
+        onClick: onClose,
+        style: {
+          position: "absolute",
+          inset: 0,
+          background: "var(--dc-bg-overlay)",
+          backdropFilter: "blur(8px)",
+          WebkitBackdropFilter: "blur(8px)"
+        }
+      }
+    ),
+    /* @__PURE__ */ React3.createElement("div", { style: {
+      position: "relative",
+      background: "var(--dc-bg)",
+      border: "1px solid var(--dc-border)",
+      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"
+    } }, /* @__PURE__ */ React3.createElement("div", { style: {
+      height: 2,
+      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,
+      height: 34,
+      borderRadius: 10,
+      background: "var(--dc-surface)",
+      border: "1px solid var(--dc-border)",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      flexShrink: 0
+    } }, /* @__PURE__ */ React3.createElement("svg", { width: "16", height: "18", viewBox: "0 0 16 18", fill: "none" }, /* @__PURE__ */ React3.createElement(
+      "path",
+      {
+        d: "M8 1L1.5 3.5V8.5C1.5 12.09 4.35 15.4 8 16.5C11.65 15.4 14.5 12.09 14.5 8.5V3.5L8 1Z",
+        stroke: "var(--dc-accent)",
+        strokeWidth: "1.4",
+        strokeLinejoin: "round"
+      }
+    ), /* @__PURE__ */ React3.createElement(
+      "path",
+      {
+        d: "M5.5 9L7 10.5L10.5 7",
+        stroke: "var(--dc-accent)",
+        strokeWidth: "1.4",
+        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(
+      "button",
+      {
+        onClick: onClose,
+        style: {
+          background: "var(--dc-surface)",
+          border: "1px solid var(--dc-border)",
+          borderRadius: 8,
+          width: 28,
+          height: 28,
+          cursor: "pointer",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          color: "var(--dc-text-muted)",
+          flexShrink: 0,
+          padding: 0
+        }
+      },
+      /* @__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: {
+      margin: "0 16px 14px",
+      padding: "8px 14px",
+      background: socialAuth.isUnlocked ? "rgba(18,183,106,0.08)" : "rgba(245,200,0,0.08)",
+      border: `1px solid ${socialAuth.isUnlocked ? "rgba(18,183,106,0.2)" : "rgba(245,200,0,0.2)"}`,
+      borderRadius: 10,
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "space-between"
+    } }, /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React3.createElement("span", { style: {
+      width: 7,
+      height: 7,
+      borderRadius: "50%",
+      flexShrink: 0,
+      background: socialAuth.isUnlocked ? "#12b76a" : "var(--dc-accent)",
+      boxShadow: `0 0 6px ${socialAuth.isUnlocked ? "#12b76a" : "var(--dc-accent)"}`
+    } }), /* @__PURE__ */ React3.createElement("span", { style: {
+      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: {
+      padding: "14px 16px",
+      borderTop: "1px solid var(--dc-border)",
+      display: "flex",
+      gap: 8
+    } }, !socialAuth.isUnlocked && /* @__PURE__ */ React3.createElement(
+      "button",
+      {
+        onClick: handleUnlock,
+        disabled: unlocking,
+        style: {
+          flex: 1,
+          padding: "10px 0",
+          background: "var(--dc-accent)",
+          color: "var(--dc-accent-text)",
+          border: "none",
+          borderRadius: 10,
+          fontSize: 13,
+          fontWeight: 700,
+          cursor: unlocking ? "not-allowed" : "pointer",
+          fontFamily: "inherit",
+          opacity: unlocking ? 0.7 : 1
+        }
+      },
+      unlocking ? "Unlocking\u2026" : "\u{1F513} Unlock wallet"
+    ), /* @__PURE__ */ React3.createElement(
+      "button",
+      {
+        onClick: handleDisconnect,
+        disabled: disconnecting,
+        style: {
+          flex: socialAuth.isUnlocked ? 1 : 0,
+          padding: "10px 16px",
+          background: "transparent",
+          border: "1px solid var(--dc-border)",
+          borderRadius: 10,
+          color: "var(--dc-text-muted)",
+          fontSize: 13,
+          cursor: disconnecting ? "not-allowed" : "pointer",
+          fontFamily: "inherit",
+          opacity: disconnecting ? 0.7 : 1,
+          whiteSpace: "nowrap"
+        }
+      },
+      disconnecting ? "Signing out\u2026" : "Sign out"
+    )))
+  );
+  return createPortal2(modal, document.body);
+}
+
 // src/ui/context.tsx
-import React3, {
+import React4, {
   createContext,
-  useCallback as useCallback2,
+  useCallback as useCallback3,
   useContext,
+  useEffect as useEffect3,
   useRef,
-  useState as useState2
+  useState as useState3
 } from "react";
+var DEFAULT_SOCIAL = {
+  addresses: null,
+  isNewUser: false,
+  isUnlocked: false,
+  sessionExpiresAt: null
+};
 var DecaneContext = createContext(null);
+function hasSocial(mode) {
+  return mode === "all" || mode === "social" || mode === "evm+social" || mode === "solana+social" || mode === "tron+social" || mode === "evm+tron+social";
+}
+function deriveNetworks(mode, explicit) {
+  if (explicit) return explicit;
+  if (mode === "evm" || mode === "evm+social") return "evm";
+  if (mode === "solana" || mode === "solana+social") return "solana";
+  if (mode === "tron" || mode === "tron+social") return "tron";
+  return "all";
+}
 function DecaneKit({ config, children }) {
-  const ref = useRef(null);
-  if (!ref.current) {
-    ref.current = createDecane(config);
-  }
-  const [selectorOpen, setSelectorOpen] = useState2(false);
-  const [theme, setTheme] = useState2(config?.theme ?? "auto");
-  const openSelector = useCallback2(() => setSelectorOpen(true), []);
-  const closeSelector = useCallback2(() => setSelectorOpen(false), []);
-  const handleConnect = useCallback2(
+  const mode = config?.mode ?? "wallets";
+  const walletRef = useRef(null);
+  if (!walletRef.current) walletRef.current = createDecane(config);
+  const socialRef = useRef(null);
+  const socialInitialized = useRef(false);
+  const [selectorOpen, setSelectorOpen] = useState3(false);
+  const [socialModalOpen, setSocialModalOpen] = useState3(false);
+  const [theme, setTheme] = useState3(config?.theme ?? "auto");
+  const [socialAuth, setSocialAuth] = useState3(DEFAULT_SOCIAL);
+  const openSelector = useCallback3(() => setSelectorOpen(true), []);
+  const closeSelector = useCallback3(() => setSelectorOpen(false), []);
+  const openSocialModal = useCallback3(() => setSocialModalOpen(true), []);
+  const closeSocialModal = useCallback3(() => setSocialModalOpen(false), []);
+  useEffect3(() => {
+    if (!socialAuth.isUnlocked) return;
+    const id = setInterval(() => {
+      const sdk = socialRef.current;
+      if (!sdk) return;
+      setSocialAuth((p) => ({
+        ...p,
+        isUnlocked: sdk.isUnlocked(),
+        sessionExpiresAt: sdk.sessionExpiresAt()
+      }));
+    }, 1e4);
+    return () => clearInterval(id);
+  }, [socialAuth.isUnlocked]);
+  useEffect3(() => {
+    if (!hasSocial(mode) || !config?.social || socialInitialized.current) return;
+    socialInitialized.current = true;
+    const { apiKey, authMethods, promptPin, apiBaseUrl, chains, rpcUrls } = config.social;
+    createDecaneConnect({
+      apiKey,
+      apiBaseUrl,
+      authMethods: authMethods ?? ["google", "email"],
+      chains: chains ?? ["evm:1", "solana:mainnet"],
+      rpcUrls,
+      promptPin
+    }).then((sdk) => {
+      socialRef.current = sdk;
+      sdk.on(
+        "session-expired",
+        () => setSocialAuth((p) => ({ ...p, isUnlocked: false, sessionExpiresAt: null }))
+      );
+      sdk.on("disconnected", () => setSocialAuth(DEFAULT_SOCIAL));
+      const saved = sdk.getAddresses();
+      if (saved) {
+        setSocialAuth((p) => ({ ...p, addresses: saved, isUnlocked: false }));
+      }
+      const params = new URLSearchParams(window.location.search);
+      if (params.has("decane_jwt") || params.has("decane_error")) {
+        sdk.connectWithGoogle().then(applyResult).catch(console.error);
+      }
+    }).catch(console.error);
+  }, []);
+  function applyResult(result) {
+    const sdk = socialRef.current;
+    setSocialAuth({
+      addresses: result.addresses,
+      isNewUser: result.isNewUser,
+      isUnlocked: sdk?.isUnlocked() ?? false,
+      sessionExpiresAt: sdk?.sessionExpiresAt() ?? null
+    });
+  }
+  const connectWithGoogle = useCallback3(async () => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social sign-in not configured");
+    await sdk.connectWithGoogle();
+  }, []);
+  const connectWithEmail = useCallback3(async (email) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social sign-in not configured");
+    return sdk.connectWithEmail(email);
+  }, []);
+  const verifyEmailCode2 = useCallback3(async (email, code) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social sign-in not configured");
+    const result = await sdk.verifyEmailCode(email, code);
+    applyResult(result);
+    setSelectorOpen(false);
+  }, []);
+  const socialUnlock = useCallback3(async () => {
+    const sdk = socialRef.current;
+    if (!sdk) return;
+    await sdk.unlock();
+    setSocialAuth((p) => ({
+      ...p,
+      isUnlocked: sdk.isUnlocked(),
+      sessionExpiresAt: sdk.sessionExpiresAt()
+    }));
+  }, []);
+  const socialDisconnect = useCallback3(async () => {
+    const sdk = socialRef.current;
+    if (!sdk) return;
+    await sdk.disconnect();
+    setSocialAuth(DEFAULT_SOCIAL);
+  }, []);
+  const socialSignMessage = useCallback3(async (chain, message) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.signMessage({ chain, message });
+  }, []);
+  const socialSendTransaction = useCallback3(async (req) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.sendTransaction({ ...req, chain: req.chain });
+  }, []);
+  const socialSignSolanaTransaction = useCallback3(async (tx) => {
+    const sdk = socialRef.current;
+    if (!sdk) throw new Error("Social wallet not connected");
+    return sdk.signSolanaTransaction(tx);
+  }, []);
+  const handleWalletConnect = useCallback3(
     (wallet, preference) => {
-      ref.current.connect(wallet, preference).catch(console.error);
+      walletRef.current.connect(wallet, preference).catch(console.error);
     },
     []
   );
-  return /* @__PURE__ */ React3.createElement(
+  const networks = deriveNetworks(mode, config?.networks);
+  return /* @__PURE__ */ React4.createElement(
     DecaneContext.Provider,
     {
-      value: { provider: ref.current, selectorOpen, openSelector, closeSelector, theme, setTheme }
+      value: {
+        provider: walletRef.current,
+        selectorOpen,
+        openSelector,
+        closeSelector,
+        theme,
+        setTheme,
+        mode,
+        socialAuth,
+        connectWithGoogle,
+        connectWithEmail,
+        verifyEmailCode: verifyEmailCode2,
+        socialUnlock,
+        socialDisconnect,
+        socialSignMessage,
+        socialSendTransaction,
+        socialSignSolanaTransaction,
+        socialModalOpen,
+        openSocialModal,
+        closeSocialModal
+      }
     },
     children,
-    /* @__PURE__ */ React3.createElement(
+    /* @__PURE__ */ React4.createElement(
       WalletSelector,
       {
-        provider: ref.current,
+        provider: walletRef.current,
         open: selectorOpen,
         onClose: closeSelector,
-        onConnect: handleConnect,
+        onConnect: handleWalletConnect,
+        theme,
+        networks,
+        mode,
+        socialAuthMethods: config?.social?.authMethods ?? ["google", "email"],
+        onGoogleSignIn: connectWithGoogle,
+        onEmailStart: connectWithEmail,
+        onEmailVerify: verifyEmailCode2
+      }
+    ),
+    /* @__PURE__ */ React4.createElement(
+      SocialWalletModal,
+      {
+        open: socialModalOpen,
+        onClose: closeSocialModal,
         theme,
-        networks: config?.networks ?? "all"
+        socialAuth,
+        onUnlock: socialUnlock,
+        onDisconnect: socialDisconnect
       }
     )
   );
@@ -2458,7 +4658,169 @@ function useDecaneContext() {
 }
 
 // src/ui/hooks.ts
-import { useState as useState3, useEffect as useEffect2, useCallback as useCallback3 } from "react";
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback4 } from "react";
+function useSocialAuth() {
+  const {
+    socialAuth,
+    connectWithGoogle,
+    connectWithEmail,
+    verifyEmailCode: verifyEmailCode2,
+    socialUnlock,
+    socialDisconnect
+  } = useDecaneContext();
+  const [googleLoading, setGoogleLoading] = useState4(false);
+  const [emailLoading, setEmailLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const signInWithGoogle = useCallback4(async () => {
+    setGoogleLoading(true);
+    setError(null);
+    try {
+      await connectWithGoogle();
+    } catch (e) {
+      setError(e.message);
+      setGoogleLoading(false);
+    }
+  }, [connectWithGoogle]);
+  const sendEmailCode = useCallback4(async (email) => {
+    setEmailLoading(true);
+    setError(null);
+    try {
+      await connectWithEmail(email);
+      return { codeRequired: true };
+    } catch (e) {
+      setError(e.message);
+      throw e;
+    } finally {
+      setEmailLoading(false);
+    }
+  }, [connectWithEmail]);
+  const confirmEmailCode = useCallback4(async (email, code) => {
+    setEmailLoading(true);
+    setError(null);
+    try {
+      await verifyEmailCode2(email, code);
+    } catch (e) {
+      setError(e.message);
+      throw e;
+    } finally {
+      setEmailLoading(false);
+    }
+  }, [verifyEmailCode2]);
+  const unlock = useCallback4(async () => {
+    setError(null);
+    try {
+      await socialUnlock();
+    } catch (e) {
+      setError(e.message);
+      throw e;
+    }
+  }, [socialUnlock]);
+  const disconnect = useCallback4(async () => {
+    setError(null);
+    try {
+      await socialDisconnect();
+    } catch (e) {
+      setError(e.message);
+      throw e;
+    }
+  }, [socialDisconnect]);
+  return {
+    isConnected: !!socialAuth.addresses,
+    isUnlocked: socialAuth.isUnlocked,
+    isNewUser: socialAuth.isNewUser,
+    addresses: socialAuth.addresses,
+    sessionExpiresAt: socialAuth.sessionExpiresAt,
+    googleLoading,
+    emailLoading,
+    error,
+    clearError: () => setError(null),
+    signInWithGoogle,
+    sendEmailCode,
+    confirmEmailCode,
+    unlock,
+    disconnect
+  };
+}
+function useSocialWallet() {
+  const {
+    socialAuth,
+    socialUnlock,
+    socialDisconnect,
+    socialSignMessage,
+    socialSendTransaction,
+    socialSignSolanaTransaction,
+    openSocialModal,
+    closeSocialModal,
+    socialModalOpen
+  } = useDecaneContext();
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  async function run(fn) {
+    setLoading(true);
+    setError(null);
+    try {
+      return await fn();
+    } catch (e) {
+      const msg = e.message;
+      setError(msg);
+      throw e;
+    } finally {
+      setLoading(false);
+    }
+  }
+  const signMessage = useCallback4(
+    (chain, message) => run(() => socialSignMessage(chain, message)),
+    [socialSignMessage]
+  );
+  const sendTransaction = useCallback4(
+    (req) => run(() => socialSendTransaction(req)),
+    [socialSendTransaction]
+  );
+  const signSolanaTransaction2 = useCallback4(
+    (tx) => run(() => socialSignSolanaTransaction(tx)),
+    [socialSignSolanaTransaction]
+  );
+  const unlock = useCallback4(async () => {
+    setError(null);
+    try {
+      await socialUnlock();
+    } catch (e) {
+      setError(e.message);
+      throw e;
+    }
+  }, [socialUnlock]);
+  const disconnect = useCallback4(async () => {
+    setError(null);
+    try {
+      await socialDisconnect();
+    } catch (e) {
+      setError(e.message);
+      throw e;
+    }
+  }, [socialDisconnect]);
+  return {
+    // State
+    isConnected: !!socialAuth.addresses,
+    isUnlocked: socialAuth.isUnlocked,
+    isNewUser: socialAuth.isNewUser,
+    addresses: socialAuth.addresses,
+    sessionExpiresAt: socialAuth.sessionExpiresAt,
+    // Modal
+    modalOpen: socialModalOpen,
+    openModal: openSocialModal,
+    closeModal: closeSocialModal,
+    // Auth
+    unlock,
+    disconnect,
+    // Signing
+    signMessage,
+    sendTransaction,
+    signSolanaTransaction: signSolanaTransaction2,
+    loading,
+    error,
+    clearError: () => setError(null)
+  };
+}
 function toDecaneError(err) {
   if (err instanceof DecaneError) return err;
   const msg = err instanceof Error ? err.message : err?.message != null ? String(err.message) : String(err);
@@ -2466,8 +4828,8 @@ function toDecaneError(err) {
 }
 function useDecane() {
   const { provider, theme, setTheme } = useDecaneContext();
-  const [, forceUpdate] = useState3(0);
-  useEffect2(() => {
+  const [, forceUpdate] = useState4(0);
+  useEffect4(() => {
     const refresh = () => forceUpdate((n) => n + 1);
     const events = [
       "connect",
@@ -2506,10 +4868,10 @@ function useWalletSelector() {
 }
 function useChainSwitch() {
   const { provider } = useDecaneContext();
-  const [, forceUpdate] = useState3(0);
-  const [loading, setLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  useEffect2(() => {
+  const [, forceUpdate] = useState4(0);
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  useEffect4(() => {
     const refresh = () => forceUpdate((n) => n + 1);
     provider.on("connect", refresh);
     provider.on("disconnect", refresh);
@@ -2518,7 +4880,7 @@ function useChainSwitch() {
       provider.off("disconnect", refresh);
     };
   }, [provider]);
-  const switchChain = useCallback3(
+  const switchChain = useCallback4(
     async (chainId) => {
       setLoading(true);
       setError(null);
@@ -2572,10 +4934,10 @@ function resolveScope(provider, chainId, account) {
 }
 function useSignMessage() {
   const { provider } = useDecaneContext();
-  const [signature, setSignature] = useState3(null);
-  const [loading, setLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const signMessage = useCallback3(
+  const [signature, setSignature] = useState4(null);
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const signMessage = useCallback4(
     async (message, options) => {
       const { chain, account } = resolveScope(
         provider,
@@ -2601,7 +4963,7 @@ function useSignMessage() {
     },
     [provider]
   );
-  const reset = useCallback3(() => {
+  const reset = useCallback4(() => {
     setSignature(null);
     setError(null);
   }, []);
@@ -2609,10 +4971,10 @@ function useSignMessage() {
 }
 function useSendTransaction() {
   const { provider } = useDecaneContext();
-  const [txHash, setTxHash] = useState3(null);
-  const [loading, setLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const sendTransaction = useCallback3(
+  const [txHash, setTxHash] = useState4(null);
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const sendTransaction = useCallback4(
     async (tx, options) => {
       const { chain, account } = resolveScope(
         provider,
@@ -2639,7 +5001,7 @@ function useSendTransaction() {
     },
     [provider]
   );
-  const reset = useCallback3(() => {
+  const reset = useCallback4(() => {
     setTxHash(null);
     setError(null);
   }, []);
@@ -2647,10 +5009,10 @@ function useSendTransaction() {
 }
 function useSignTypedData() {
   const { provider } = useDecaneContext();
-  const [signature, setSignature] = useState3(null);
-  const [loading, setLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const signTypedData = useCallback3(
+  const [signature, setSignature] = useState4(null);
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const signTypedData = useCallback4(
     async (typedData, options) => {
       const { chain, account } = resolveScope(
         provider,
@@ -2676,25 +5038,50 @@ function useSignTypedData() {
     },
     [provider]
   );
-  const reset = useCallback3(() => {
+  const reset = useCallback4(() => {
     setSignature(null);
     setError(null);
   }, []);
   return { signTypedData, signature, loading, error, reset };
 }
 export {
+  AttestationError,
   BUILT_IN_CHAINS,
   CHAINS,
+  CallSequenceError,
+  DecaneConnectError,
   DecaneError,
   DecaneErrorCode,
   DecaneKit,
+  ExportNotAuthorizedError,
+  InvalidApiKeyError,
+  InvalidPinError,
+  InvalidRecoveryFileError,
+  NetworkError,
+  NewDeviceError,
+  OriginNotAllowedError,
+  PromptPinNotConfiguredError,
+  RecoveryFailedError,
+  RecoveryWalletMismatchError,
+  SessionExpiredError,
+  ShareCorruptedError,
+  SocialWalletModal,
+  UnlockRequiredError,
+  UserCancelledError,
   WalletSelector,
+  WebAuthnNotSupportedError,
+  WrongPasswordError,
   createDecane,
+  createDecaneConnect,
+  startEmailAuth,
   useChainSwitch,
   useDecane,
   useSendTransaction,
   useSignMessage,
   useSignTypedData,
-  useWalletSelector
+  useSocialAuth,
+  useSocialWallet,
+  useWalletSelector,
+  verifyEmailCode
 };
 //# sourceMappingURL=index.js.map