decane-connect-kit 1.0.1 → 1.0.3

package/dist/index.js

@@ -1670,6 +1670,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 +1695,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,6 +1733,1171 @@ function createDecane(config = {}) {
   return createProvider({ config, registry, session, chainStore, router, emitter });
 }
 
+// src/social/client.ts
+import { Wallet } from "ethers";
+import { Transaction as Transaction2, VersionedTransaction, Keypair } from "@solana/web3.js";
+
+// src/social/errors.ts
+var DecaneConnectError = class extends Error {
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.name = "DecaneConnectError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+var InvalidApiKeyError = class extends DecaneConnectError {
+  constructor() {
+    super("INVALID_API_KEY", "API key is invalid or revoked");
+  }
+};
+var OriginNotAllowedError = class extends DecaneConnectError {
+  constructor(origin) {
+    super("ORIGIN_NOT_ALLOWED", `Origin ${origin} not in API key allowlist`);
+  }
+};
+var SessionExpiredError = class extends DecaneConnectError {
+  constructor() {
+    super("SESSION_EXPIRED", "Session has expired \u2014 call unlock()", true);
+  }
+};
+var UnlockRequiredError = class extends DecaneConnectError {
+  constructor() {
+    super("UNLOCK_REQUIRED", "Wallet must be unlocked before signing", true);
+  }
+};
+var UserCancelledError = class extends DecaneConnectError {
+  constructor() {
+    super("USER_CANCELLED", "User cancelled the operation", true);
+  }
+};
+var WebAuthnNotSupportedError = class extends DecaneConnectError {
+  constructor() {
+    super("WEBAUTHN_UNSUPPORTED", "This browser does not support WebAuthn");
+  }
+};
+var InvalidPinError = class extends DecaneConnectError {
+  constructor() {
+    super("INVALID_PIN", "Incorrect PIN", true);
+  }
+};
+var CallSequenceError = class extends DecaneConnectError {
+  constructor(msg) {
+    super("CALL_SEQUENCE", msg);
+  }
+};
+var NetworkError = class extends DecaneConnectError {
+  constructor() {
+    super("NETWORK", "Network request failed", true);
+  }
+};
+var ShareCorruptedError = class extends DecaneConnectError {
+  constructor() {
+    super("SHARE_CORRUPTED", "Stored device share is corrupted");
+  }
+};
+var NewDeviceError = class extends DecaneConnectError {
+  constructor() {
+    super("NEW_DEVICE", "No device share found. Re-authenticate to set up this device.");
+  }
+};
+var PromptPinNotConfiguredError = class extends DecaneConnectError {
+  constructor() {
+    super("PROMPT_PIN_NOT_CONFIGURED", "Passkey unavailable and no promptPin callback was provided in config");
+  }
+};
+var AttestationError = class extends DecaneConnectError {
+  constructor(msg) {
+    super("ATTESTATION_FAILED", msg);
+  }
+};
+var RecoveryFailedError = class extends DecaneConnectError {
+  constructor(reason) {
+    super("RECOVERY_FAILED", `Recovery failed: ${reason}`, true);
+  }
+};
+var InvalidPhraseError = class extends DecaneConnectError {
+  constructor() {
+    super("INVALID_PHRASE", "Recovery phrase is invalid or corrupted", true);
+  }
+};
+
+// src/social/events.ts
+var EventEmitter = class {
+  constructor() {
+    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);
+  }
+};
+
+// src/social/api.ts
+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
+      })
+    });
+  }
+  async revoke(jwt) {
+    await this._request("/auth/revoke", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+  }
+  // ── Recovery (passkey-sync backup + phrase-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 markPhraseSaved(jwt) {
+    await this._request("/recovery/phrase-saved", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+  }
+};
+function bytesToB64(bytes) {
+  return btoa(String.fromCharCode(...bytes));
+}
+function b64ToBytes(b642) {
+  return Uint8Array.from(atob(b642), (c) => c.charCodeAt(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/attestation.ts
+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)"}`
+    );
+  }
+}
+
+// src/social/teeClient.ts
+function bytesToBase64(b) {
+  let s = "";
+  for (const byte of b) s += String.fromCharCode(byte);
+  return btoa(s);
+}
+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;
+  }
+  /** Verify a candidate device share (from a recovery phrase) without exposing shares. */
+  async verifyRecoveryCandidate(deviceShare, jwt) {
+    await this.ensureAttested();
+    const res = await fetch(`${this.teeUrl}/signer/verify-recovery`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ deviceShare: bytesToBase64(deviceShare) })
+    });
+    if (!res.ok) return false;
+    return (await res.json()).verified === true;
+  }
+  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
+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
+function xorBytes(a, b) {
+  if (a.length !== b.length) throw new Error("xorBytes: length mismatch");
+  const out = new Uint8Array(a.length);
+  for (let i = 0; i < a.length; i++) out[i] = a[i] ^ b[i];
+  return out;
+}
+function generateRandomBytes(n) {
+  return crypto.getRandomValues(new Uint8Array(n));
+}
+function generateWalletShares() {
+  const privateKey = generateRandomBytes(32);
+  const deviceShare = generateRandomBytes(32);
+  const serverShare = xorBytes(privateKey, deviceShare);
+  return { privateKey, deviceShare, serverShare };
+}
+function zeroize(bytes) {
+  bytes.fill(0);
+}
+
+// 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
+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) {
+  const challenge = crypto.getRandomValues(new Uint8Array(32));
+  let cred;
+  try {
+    cred = await navigator.credentials.create({
+      publicKey: {
+        challenge: buf3(challenge),
+        rp: { id: opts.rpId, name: opts.rpName },
+        user: { id: buf3(opts.userId), name: opts.userName, displayName: opts.userName },
+        pubKeyCredParams: [
+          { type: "public-key", alg: -7 },
+          { type: "public-key", alg: -257 }
+        ],
+        authenticatorSelection: { userVerification: "required", residentKey: "preferred" },
+        extensions: { prf: { eval: { first: buf3(opts.prfSalt) } } }
+      }
+    });
+  } catch (e) {
+    if (e.name === "NotAllowedError") throw new UserCancelledError();
+    throw e;
+  }
+  const ext = cred.getClientExtensionResults();
+  const prfResults = ext?.prf?.results;
+  const prfOutput = prfResults?.first ? new Uint8Array(prfResults.first) : void 0;
+  return { credentialId: new Uint8Array(cred.rawId), prfOutput };
+}
+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/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/phrase.ts
+import { entropyToMnemonic, mnemonicToEntropy, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+function shareToPhrase(deviceShare) {
+  if (deviceShare.length !== 32) throw new Error("deviceShare must be 32 bytes");
+  return entropyToMnemonic(deviceShare, wordlist);
+}
+function phraseToShare(phrase) {
+  const normalized = phrase.trim().toLowerCase().split(/\s+/).join(" ");
+  if (!validateMnemonic(normalized, wordlist)) throw new InvalidPhraseError();
+  const entropy = mnemonicToEntropy(normalized, wordlist);
+  if (entropy.length !== 32) throw new InvalidPhraseError();
+  return entropy;
+}
+function phraseConfirmationChallenge(phrase) {
+  const words = phrase.trim().split(/\s+/);
+  const chosen = /* @__PURE__ */ new Set();
+  while (chosen.size < 3) chosen.add(Math.floor(Math.random() * words.length));
+  return [...chosen].sort((a, b) => a - b).map((i) => ({ position: i + 1, expected: words[i] }));
+}
+
+// src/social/recovery/recoveryFlow.ts
+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.promptForPhrase) throw new NewDeviceError();
+  input.onProgress?.({ type: "phrase-prompt" });
+  const phrase = await input.promptForPhrase();
+  if (!phrase) throw new NewDeviceError();
+  let candidate;
+  try {
+    candidate = phraseToShare(phrase);
+  } catch {
+    throw new InvalidPhraseError();
+  }
+  input.onProgress?.({ type: "phrase-verifying" });
+  const tee = new TeeClient(input.teeUrl);
+  const verified = await tee.verifyRecoveryCandidate(candidate, input.jwt);
+  if (!verified) {
+    zeroize(candidate);
+    throw new RecoveryFailedError("phrase-mismatch");
+  }
+  return candidate;
+}
+
+// src/social/recovery/phraseUi.ts
+function buildPhraseResult(deviceShare) {
+  const phrase = shareToPhrase(deviceShare);
+  return { phrase, challenge: phraseConfirmationChallenge(phrase) };
+}
+function verifyConfirmationChallenge(challenge, userAnswers) {
+  if (userAnswers.length !== challenge.length) return false;
+  return challenge.every(({ position, expected }) => {
+    const answer = userAnswers.find((a) => a.position === position);
+    return !!answer && answer.word.trim().toLowerCase() === expected.toLowerCase();
+  });
+}
+
+// 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 authType = config.authMethods[0] ?? "social";
+      const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const result = await registerPasskey({
+        rpId,
+        rpName,
+        userId: new TextEncoder().encode(userId),
+        userName: `decane-wallet-${authType}-${dateStr}`,
+        prfSalt
+      });
+      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 authType = config.authMethods[0] ?? "social";
+        const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        const { credentialId, prfOutput } = await registerPasskey({
+          rpId,
+          rpName,
+          userId: new TextEncoder().encode(userId),
+          userName: `decane-wallet-${authType}-${dateStr}`,
+          prfSalt
+        });
+        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 { privateKey, deviceShare, serverShare } = generateWalletShares();
+    let evmAddress;
+    let solanaAddress;
+    try {
+      evmAddress = new Wallet(toHex(privateKey)).address;
+      solanaAddress = Keypair.fromSeed(privateKey).publicKey.toBase58();
+    } finally {
+      zeroize(privateKey);
+    }
+    const iv = generateRandomBytes(12);
+    const wrappedDeviceShare = await aesGcmEncrypt(
+      wrappingKey,
+      deviceShare,
+      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: serverShare,
+      iv: serverIv,
+      wrappedShareMeta: {
+        unlockMethod
+        // credential IDs, prfSalt, pinSalt stay on-device — never sent to server
+      },
+      evmAddress,
+      solanaAddress
+    });
+    zeroize(serverShare);
+    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(deviceShare, jwt, addresses);
+    if (config.offerPhraseAtSignup !== false && config.onPhraseGenerated) {
+      try {
+        const result = buildPhraseResult(deviceShare);
+        const { userConfirmed, userAnswers } = await config.onPhraseGenerated(result);
+        if (userConfirmed && verifyConfirmationChallenge(result.challenge, userAnswers)) {
+          await api.markPhraseSaved(jwt);
+        }
+      } catch (e) {
+        console.warn("decane-connect-kit: recovery phrase offer failed or was skipped.", e);
+      }
+    }
+    zeroize(deviceShare);
+    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,
+        promptForPhrase: config.promptForRecoveryPhrase
+      });
+      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 generateRecoveryPhrase() {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      const stored = await storage.getShare(auth.userId);
+      if (!stored) throw new NewDeviceError();
+      const wrappingKey = await getWrappingKey(stored);
+      const deviceShare = await aesGcmDecrypt(wrappingKey, stored.wrappedDeviceShare, stored.iv);
+      try {
+        return buildPhraseResult(deviceShare);
+      } finally {
+        zeroize(deviceShare);
+      }
+    },
+    async markPhraseSaved(challenge, userAnswers) {
+      if (!auth) throw new CallSequenceError("Not connected \u2014 call connect() first");
+      if (!verifyConfirmationChallenge(challenge, userAnswers)) return false;
+      await api.markPhraseSaved(auth.jwt);
+      return true;
+    },
+    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(buf4) {
+  return btoa(String.fromCharCode(...buf4)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function b64uToBuffer(b64u) {
+  const b642 = b64u.replace(/-/g, "+").replace(/_/g, "/");
+  return Uint8Array.from(atob(b642), (c) => c.charCodeAt(0));
+}
+function toHex(bytes) {
+  return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
 // src/ui/WalletSelector.tsx
 import React2, { useEffect, useCallback, useState } from "react";
 import { createPortal } from "react-dom";
@@ -2083,17 +3250,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 +3292,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 +3553,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 +3585,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 +3644,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 +4281,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 +4451,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 +4491,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 +4503,7 @@ function useChainSwitch() {
       provider.off("disconnect", refresh);
     };
   }, [provider]);
-  const switchChain = useCallback3(
+  const switchChain = useCallback4(
     async (chainId) => {
       setLoading(true);
       setError(null);
@@ -2572,10 +4557,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 +4586,7 @@ function useSignMessage() {
     },
     [provider]
   );
-  const reset = useCallback3(() => {
+  const reset = useCallback4(() => {
     setSignature(null);
     setError(null);
   }, []);
@@ -2609,10 +4594,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 +4624,7 @@ function useSendTransaction() {
     },
     [provider]
   );
-  const reset = useCallback3(() => {
+  const reset = useCallback4(() => {
     setTxHash(null);
     setError(null);
   }, []);
@@ -2647,10 +4632,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 +4661,47 @@ 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,
+  InvalidApiKeyError,
+  InvalidPhraseError,
+  InvalidPinError,
+  NetworkError,
+  NewDeviceError,
+  OriginNotAllowedError,
+  PromptPinNotConfiguredError,
+  RecoveryFailedError,
+  SessionExpiredError,
+  ShareCorruptedError,
+  SocialWalletModal,
+  UnlockRequiredError,
+  UserCancelledError,
   WalletSelector,
+  WebAuthnNotSupportedError,
   createDecane,
+  createDecaneConnect,
+  startEmailAuth,
   useChainSwitch,
   useDecane,
   useSendTransaction,
   useSignMessage,
   useSignTypedData,
-  useWalletSelector
+  useSocialAuth,
+  useSocialWallet,
+  useWalletSelector,
+  verifyEmailCode
 };
 //# sourceMappingURL=index.js.map