hd-wallet-ui 1.2.0 → 1.2.2

package/src/app.js

@@ -20,7 +20,7 @@ import { Buffer } from 'buffer';
 import { createV3 } from 'vcard-cryptoperson';
 
 // SpaceDataStandards EME (Encrypted Message Envelope)
-import { EME, EMET } from '@sds/lib/js/ts/EME/EME.js';
+import { EME, EMET } from '@sds/lib/js/EME/EME.js';
 import * as flatbuffers from 'flatbuffers';
 
 // Make Buffer available globally for various crypto libraries
@@ -229,6 +229,18 @@ const state = {
   encryptionIV: null,
   // vCard photo (base64 data URI)
   vcardPhoto: null,
+  // Active accounts discovered by scanning or manually added
+  activeAccounts: [],
+  // Wallet groups (Phantom-style: each wallet = same account index across chains)
+  wallets: [{ id: 0, name: 'Wallet 1', accountIndex: 0 }],
+  activeWalletId: 0,
+  walletManageTab: 'active',
+  walletFiatTotals: {},
+  walletFiatCurrency: 'USD',
+  balanceCache: {},
+  balanceCacheLoaded: false,
+  balanceRateLimitUntil: {},
+  scanInProgress: false,
   // PKI Demo state
   pki: {
     alice: null,
@@ -454,6 +466,1552 @@ function updatePathDisplay() {
   if (encryptionPathEl) encryptionPathEl.textContent = encryptionPath;
 }
 
+// =============================================================================
+// Active Accounts: Derivation, Persistence, Scanning, Rendering
+// =============================================================================
+
+/**
+ * Derive an address for a given BIP44 path.
+ * SOL (501) uses ed25519; BTC (0) and ETH (60) use secp256k1.
+ * @returns {{ address: string, publicKey: Uint8Array, path: string }}
+ */
+function deriveAddressForPath(coinType, account, index) {
+  if (!state.hdRoot) throw new Error('HD wallet not initialized');
+  const path = buildSigningPath(coinType, account, index);
+  const derived = state.hdRoot.derivePath(path);
+
+  if (coinType === 501) {
+    // Solana: ed25519
+    const privKey = derived.privateKey();
+    const pubKey = ed25519.getPublicKey(privKey);
+    return { address: generateSolAddress(pubKey), publicKey: pubKey, path };
+  }
+
+  // BTC/ETH: secp256k1
+  const pubKey = derived.publicKey();
+  return { address: generateAddressForCoin(pubKey, coinType), publicKey: pubKey, path };
+}
+
+const ACTIVE_ACCOUNTS_KEY = 'hd-wallet-active-accounts';
+const WALLETS_KEY = 'hd-wallet-wallets';
+const DEFAULT_WALLET_COUNT = 10;
+const WALLET_OVERLAY_VIEWS = ['wallet-wallets-view', 'wallet-export-view', 'wallet-advanced-view', 'wallet-send-view'];
+const BALANCE_CACHE_KEY = 'hd-wallet-scan-balance-cache-v1';
+const BALANCE_CACHE_TTL_MS = 2 * 60 * 1000;
+const BALANCE_CACHE_STALE_MS = 30 * 60 * 1000;
+const SCAN_REQUEST_DELAY_MS = 700;
+const SCAN_RETRY_BASE_DELAY_MS = 1200;
+const SCAN_MAX_RETRIES = 2;
+const BALANCE_RATE_LIMIT_COOLDOWN_MS = 2 * 60 * 1000;
+let _scanLastRequestAt = 0;
+let _balanceCacheDirty = false;
+
+function getDefaultWalletState() {
+  return [{ id: 0, name: 'Wallet 1', accountIndex: 0, inactive: false }];
+}
+
+function getDefaultWalletName(accountIndex) {
+  return `Wallet ${accountIndex + 1}`;
+}
+
+function normalizeWalletName(rawName, accountIndex) {
+  const fallback = getDefaultWalletName(accountIndex);
+  const trimmed = (rawName || '').toString().trim();
+  if (!trimmed) return fallback;
+  if (/^wallet(?:\s+\d+)?$/i.test(trimmed)) return fallback;
+  return trimmed;
+}
+
+function ensureWalletNamesNormalized() {
+  let changed = false;
+  state.wallets.forEach((wallet) => {
+    const normalized = normalizeWalletName(wallet.name, wallet.accountIndex);
+    if (normalized !== wallet.name) {
+      wallet.name = normalized;
+      changed = true;
+    }
+  });
+  if (changed) saveWallets();
+  return changed;
+}
+
+function getWalletDerivationEntries(wallet) {
+  return [
+    { coinType: 0, name: 'BTC', account: wallet.accountIndex, index: 0 },
+    { coinType: 60, name: 'ETH', account: 0, index: wallet.accountIndex },
+    { coinType: 501, name: 'SOL', account: wallet.accountIndex, index: 0 },
+  ];
+}
+
+function getWalletIdForPath(coinType, account, index) {
+  const accountIndex = coinType === 60 ? index : account;
+  const wallet = state.wallets.find(w => w.accountIndex === accountIndex);
+  return wallet ? wallet.id : 0;
+}
+
+function isWalletInactive(wallet) {
+  return Boolean(wallet?.inactive);
+}
+
+function getActiveWallets() {
+  return state.wallets.filter(wallet => !isWalletInactive(wallet));
+}
+
+function getInactiveWallets() {
+  return state.wallets.filter(wallet => isWalletInactive(wallet));
+}
+
+function normalizeWallets(wallets) {
+  const normalized = [];
+  const source = Array.isArray(wallets) ? wallets : [];
+  const usedIds = new Set();
+  const usedAccountIndexes = new Set();
+
+  for (const wallet of source) {
+    const id = Number.parseInt(wallet?.id, 10);
+    const accountIndex = Number.parseInt(wallet?.accountIndex, 10);
+    if (Number.isNaN(id) || Number.isNaN(accountIndex)) continue;
+    if (usedIds.has(id) || usedAccountIndexes.has(accountIndex)) continue;
+
+    const name = normalizeWalletName(wallet?.name, accountIndex);
+    const inactive = Boolean(wallet?.inactive);
+    normalized.push({ id, name, accountIndex, inactive });
+    usedIds.add(id);
+    usedAccountIndexes.add(accountIndex);
+  }
+
+  let nextId = normalized.reduce((max, wallet) => Math.max(max, wallet.id), -1) + 1;
+  for (let accountIndex = 0; accountIndex < DEFAULT_WALLET_COUNT; accountIndex++) {
+    if (usedAccountIndexes.has(accountIndex)) continue;
+    while (usedIds.has(nextId)) nextId++;
+    normalized.push({
+      id: nextId,
+      name: getDefaultWalletName(accountIndex),
+      accountIndex,
+      inactive: false,
+    });
+    usedIds.add(nextId);
+  }
+
+  if (normalized.length === 0) return getDefaultWalletState();
+  normalized.sort((a, b) => a.accountIndex - b.accountIndex || a.id - b.id);
+  return normalized;
+}
+
+function normalizeActiveAccounts(accounts) {
+  const source = Array.isArray(accounts) ? accounts : [];
+  return source.map((acct) => {
+    const existingWalletId = Number.parseInt(acct.walletId, 10);
+    const walletExists = state.wallets.some(w => w.id === existingWalletId);
+    const walletId = walletExists
+      ? existingWalletId
+      : getWalletIdForPath(Number.parseInt(acct.coinType, 10), Number.parseInt(acct.account, 10), Number.parseInt(acct.index, 10));
+    return { ...acct, walletId };
+  });
+}
+
+function ensureWalletAccounts() {
+  if (!state.hdRoot) return false;
+
+  const existing = new Set(
+    state.activeAccounts.map(a => `${a.walletId ?? getWalletIdForPath(a.coinType, a.account, a.index)}:${a.coinType}:${a.account}:${a.index}`)
+  );
+  let added = false;
+
+  for (const wallet of state.wallets) {
+    for (const entry of getWalletDerivationEntries(wallet)) {
+      const key = `${wallet.id}:${entry.coinType}:${entry.account}:${entry.index}`;
+      if (existing.has(key)) continue;
+      try {
+        const { address, path } = deriveAddressForPath(entry.coinType, entry.account, entry.index);
+        state.activeAccounts.push({
+          coinType: entry.coinType,
+          name: entry.name,
+          account: entry.account,
+          index: entry.index,
+          address,
+          path,
+          balance: '--',
+          active: false,
+          walletId: wallet.id,
+        });
+        existing.add(key);
+        added = true;
+      } catch (e) {
+        console.warn('Failed to derive wallet account:', entry, e);
+      }
+    }
+  }
+
+  if (added) saveActiveAccounts();
+  return added;
+}
+
+function getWalletById(walletId) {
+  return state.wallets.find(w => w.id === walletId);
+}
+
+function getCurrentWallet() {
+  const activeWallets = getActiveWallets();
+  if (activeWallets.length === 0) return null;
+  const current = activeWallets.find(wallet => wallet.id === state.activeWalletId);
+  return current || activeWallets[0] || null;
+}
+
+function getAccountWalletId(acct) {
+  if (!acct) return 0;
+  if (acct.walletId !== undefined && getWalletById(acct.walletId)) return acct.walletId;
+  return getWalletIdForPath(acct.coinType, acct.account, acct.index);
+}
+
+function isSigningAccountForWallet(acct, wallet) {
+  if (!acct || !wallet) return false;
+  const coinType = Number.parseInt(acct.coinType, 10);
+  const account = Number.parseInt(acct.account, 10);
+  const index = Number.parseInt(acct.index, 10);
+  if (Number.isNaN(coinType) || Number.isNaN(account) || Number.isNaN(index)) return false;
+
+  if (coinType === 60) return account === 0 && index === wallet.accountIndex;
+  if (coinType === 0 || coinType === 501) return account === wallet.accountIndex && index === 0;
+  return false;
+}
+
+function isSigningAccount(acct) {
+  const wallet = getWalletById(getAccountWalletId(acct));
+  return isSigningAccountForWallet(acct, wallet);
+}
+
+function updateCustomPathWalletLabel() {
+  const label = $('custom-path-wallet-label');
+  const wallet = getCurrentWallet();
+  if (!label) return;
+  label.textContent = wallet ? `${wallet.name} (account ${wallet.accountIndex})` : `${getDefaultWalletName(0)} (account 0)`;
+}
+
+function updateCustomPathDefault() {
+  const chainSelect = $('custom-path-chain');
+  const input = $('custom-path-input');
+  const wallet = getCurrentWallet();
+  if (!chainSelect || !input || !wallet) return;
+
+  const coinType = Number.parseInt(chainSelect.value, 10);
+  if (Number.isNaN(coinType)) return;
+  const account = coinType === 60 ? 0 : wallet.accountIndex;
+  const index = coinType === 60 ? wallet.accountIndex : 0;
+  input.value = buildSigningPath(coinType, account, index);
+  input.dataset.autogenerated = 'true';
+}
+
+function renderWalletSelector() {
+  const select = $('wallet-active-select');
+  if (!select) return;
+  ensureWalletNamesNormalized();
+
+  const currentWallet = getCurrentWallet();
+  if (!currentWallet) {
+    select.innerHTML = '';
+    return;
+  }
+  state.activeWalletId = currentWallet.id;
+
+  select.innerHTML = '';
+  const displayCurrency = state.walletFiatCurrency || getSelectedCurrency();
+  const activeWallets = getActiveWallets();
+  activeWallets.forEach((wallet) => {
+    const option = document.createElement('option');
+    option.value = String(wallet.id);
+    const walletValue = state.walletFiatTotals[wallet.id] ?? 0;
+    option.textContent = `${wallet.name} (${formatCurrencyValue(walletValue, displayCurrency)})`;
+    select.appendChild(option);
+  });
+  select.value = String(state.activeWalletId);
+  updateCustomPathWalletLabel();
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function loadBalanceCache() {
+  try {
+    const raw = localStorage.getItem(BALANCE_CACHE_KEY);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function saveBalanceCache() {
+  if (!_balanceCacheDirty) return;
+  try {
+    localStorage.setItem(BALANCE_CACHE_KEY, JSON.stringify(state.balanceCache));
+    _balanceCacheDirty = false;
+  } catch (e) {
+    console.warn('Failed to save balance cache:', e);
+  }
+}
+
+function pruneBalanceCache() {
+  const now = Date.now();
+  let changed = false;
+  Object.entries(state.balanceCache).forEach(([key, entry]) => {
+    if (!entry || typeof entry.ts !== 'number' || now - entry.ts > BALANCE_CACHE_STALE_MS) {
+      delete state.balanceCache[key];
+      changed = true;
+    }
+  });
+  if (changed) _balanceCacheDirty = true;
+}
+
+function getBalanceCacheKey(coinType, address) {
+  return `${coinType}:${address}`;
+}
+
+function isNumericBalance(balance) {
+  const n = Number.parseFloat(balance);
+  return Number.isFinite(n) && n >= 0;
+}
+
+function getCachedBalance(coinType, address, { allowStale = false } = {}) {
+  const key = getBalanceCacheKey(coinType, address);
+  const entry = state.balanceCache[key];
+  if (!entry || typeof entry.balance !== 'string' || typeof entry.ts !== 'number') return null;
+
+  const age = Date.now() - entry.ts;
+  if (age <= BALANCE_CACHE_TTL_MS) return { ...entry, stale: false };
+  if (allowStale && age <= BALANCE_CACHE_STALE_MS) return { ...entry, stale: true };
+  return null;
+}
+
+function setCachedBalance(coinType, address, balance) {
+  if (!isNumericBalance(balance)) return;
+  state.balanceCache[getBalanceCacheKey(coinType, address)] = {
+    balance: String(balance),
+    ts: Date.now(),
+  };
+  _balanceCacheDirty = true;
+}
+
+function hydrateAccountsFromBalanceCache() {
+  let changed = false;
+  for (const acct of state.activeAccounts) {
+    if (!acct?.address) continue;
+    const cached = getCachedBalance(acct.coinType, acct.address, { allowStale: true });
+    if (!cached || !isNumericBalance(cached.balance)) continue;
+
+    const prev = Number.parseFloat(acct.balance);
+    const next = Number.parseFloat(cached.balance);
+    if (!Number.isFinite(prev) || Math.abs(prev - next) > 1e-12) {
+      acct.balance = cached.balance;
+      changed = true;
+    }
+    if (next > 0 && !acct.active) {
+      acct.active = true;
+      changed = true;
+    }
+  }
+  if (changed) saveActiveAccounts();
+  return changed;
+}
+
+function isRateLimitError(message) {
+  const text = (message || '').toLowerCase();
+  return text.includes('429')
+    || text.includes('rate')
+    || text.includes('limit')
+    || text.includes('too many')
+    || text.includes('throttl')
+    || text.includes('quota');
+}
+
+async function waitForScanThrottle() {
+  const now = Date.now();
+  const elapsed = now - _scanLastRequestAt;
+  if (elapsed < SCAN_REQUEST_DELAY_MS) {
+    await sleep(SCAN_REQUEST_DELAY_MS - elapsed);
+  }
+  _scanLastRequestAt = Date.now();
+}
+
+function findExistingAccountForTarget(target) {
+  return state.activeAccounts.find(a =>
+    getAccountWalletId(a) === target.walletId
+    && a.coinType === target.coinType
+    && a.account === target.account
+    && a.index === target.index
+  );
+}
+
+async function fetchBalanceForScanTarget(target, address) {
+  const cooldownUntil = state.balanceRateLimitUntil[target.coinType] || 0;
+  if (Date.now() < cooldownUntil) {
+    const stale = getCachedBalance(target.coinType, address, { allowStale: true });
+    if (stale) {
+      return {
+        ok: true,
+        balance: stale.balance,
+        source: 'cache',
+        stale: true,
+        error: 'Rate-limited; using cached balance',
+      };
+    }
+    return {
+      ok: false,
+      balance: '--',
+      source: 'none',
+      stale: false,
+      error: 'Rate-limited; retrying later',
+    };
+  }
+
+  const fresh = getCachedBalance(target.coinType, address);
+  if (fresh) {
+    return {
+      ok: true,
+      balance: fresh.balance,
+      source: 'cache',
+      stale: false,
+    };
+  }
+
+  let lastError = '';
+  for (let attempt = 0; attempt <= SCAN_MAX_RETRIES; attempt++) {
+    await waitForScanThrottle();
+    try {
+      const result = await target.fetchBalance(address);
+      const balance = result?.balance;
+      const error = result?.error;
+      if (!error && isNumericBalance(balance)) {
+        state.balanceRateLimitUntil[target.coinType] = 0;
+        setCachedBalance(target.coinType, address, balance);
+        return {
+          ok: true,
+          balance: String(balance),
+          source: 'network',
+          stale: false,
+        };
+      }
+
+      lastError = error || 'Unknown balance fetch error';
+      if (isRateLimitError(lastError)) {
+        state.balanceRateLimitUntil[target.coinType] = Date.now() + BALANCE_RATE_LIMIT_COOLDOWN_MS;
+      }
+    } catch (e) {
+      lastError = e?.message || 'Unknown balance fetch exception';
+      if (isRateLimitError(lastError)) {
+        state.balanceRateLimitUntil[target.coinType] = Date.now() + BALANCE_RATE_LIMIT_COOLDOWN_MS;
+      }
+    }
+
+    const retryable = isRateLimitError(lastError) || lastError.length > 0;
+    if (attempt < SCAN_MAX_RETRIES && retryable) {
+      const delay = SCAN_RETRY_BASE_DELAY_MS * (attempt + 1);
+      await sleep(delay);
+      continue;
+    }
+  }
+
+  const stale = getCachedBalance(target.coinType, address, { allowStale: true });
+  if (stale) {
+    return {
+      ok: true,
+      balance: stale.balance,
+      source: 'cache',
+      stale: true,
+      error: lastError,
+    };
+  }
+
+  return {
+    ok: false,
+    balance: '--',
+    source: 'none',
+    stale: false,
+    error: lastError || 'Balance unavailable',
+  };
+}
+
+function saveActiveAccounts() {
+  try {
+    const serializable = state.activeAccounts.map(a => ({
+      coinType: a.coinType,
+      name: a.name,
+      account: a.account,
+      index: a.index,
+      address: a.address,
+      balance: a.balance,
+      active: a.active,
+      path: a.path,
+      walletId: a.walletId ?? 0,
+    }));
+    localStorage.setItem(ACTIVE_ACCOUNTS_KEY, JSON.stringify(serializable));
+  } catch (e) {
+    console.warn('Failed to save active accounts:', e);
+  }
+}
+
+function loadActiveAccounts() {
+  try {
+    const saved = localStorage.getItem(ACTIVE_ACCOUNTS_KEY);
+    return saved ? JSON.parse(saved) : [];
+  } catch {
+    return [];
+  }
+}
+
+function saveWallets() {
+  try {
+    localStorage.setItem(WALLETS_KEY, JSON.stringify(state.wallets));
+  } catch (e) {
+    console.warn('Failed to save wallets:', e);
+  }
+}
+
+function loadWallets() {
+  try {
+    const saved = localStorage.getItem(WALLETS_KEY);
+    return normalizeWallets(saved ? JSON.parse(saved) : getDefaultWalletState());
+  } catch {
+    return normalizeWallets(getDefaultWalletState());
+  }
+}
+
+/**
+ * Create a new wallet (Phantom-style: all chains at same account index N).
+ * BTC: m/44'/0'/N'/0/0, ETH: m/44'/60'/0'/0/N, SOL: m/44'/501'/N'/0
+ */
+function createNewWallet(walletName) {
+  if (!state.hdRoot) return;
+
+  const maxIdx = state.wallets.reduce((m, w) => Math.max(m, w.accountIndex), -1);
+  const nextIdx = maxIdx + 1;
+  const nextId = state.wallets.reduce((m, w) => Math.max(m, w.id), -1) + 1;
+  const name = normalizeWalletName(walletName, nextIdx);
+
+  const wallet = { id: nextId, name, accountIndex: nextIdx, inactive: false };
+  state.wallets.push(wallet);
+  saveWallets();
+
+  // Derive addresses for each chain at the new account index
+  const chainDerivations = [
+    { coinType: 0,   name: 'BTC', account: nextIdx, index: 0 },     // BTC: m/44'/0'/N'/0/0
+    { coinType: 60,  name: 'ETH', account: 0,       index: nextIdx }, // ETH: m/44'/60'/0'/0/N
+    { coinType: 501, name: 'SOL', account: nextIdx,  index: 0 },     // SOL: m/44'/501'/N'/0
+  ];
+
+  for (const cd of chainDerivations) {
+    try {
+      const { address, path } = deriveAddressForPath(cd.coinType, cd.account, cd.index);
+      state.activeAccounts.push({
+        coinType: cd.coinType,
+        name: cd.name,
+        account: cd.account,
+        index: cd.index,
+        address,
+        path,
+        balance: '--',
+        active: false,
+        walletId: nextId,
+      });
+    } catch (e) {
+      console.warn('Failed to derive for new wallet:', cd.name, e);
+    }
+  }
+
+  saveActiveAccounts();
+  state.activeWalletId = nextId;
+  renderAccountsList();
+  renderWalletList();
+  renderWalletSelector();
+  updateCustomPathDefault();
+}
+
+function renameWallet(walletId, newName) {
+  const wallet = state.wallets.find(w => w.id === walletId);
+  if (!wallet) return;
+  wallet.name = normalizeWalletName(newName, wallet.accountIndex);
+  saveWallets();
+  renderAccountsList();
+  renderWalletSelector();
+  updateCustomPathWalletLabel();
+}
+
+function setWalletInactive(walletId, inactive) {
+  const wallet = getWalletById(walletId);
+  if (!wallet) return;
+
+  if (!inactive && !isWalletInactive(wallet)) return;
+  if (inactive && isWalletInactive(wallet)) return;
+
+  if (inactive && getActiveWallets().length <= 1) {
+    alert('At least one active wallet is required.');
+    return;
+  }
+
+  wallet.inactive = inactive;
+  if (inactive && state.activeWalletId === walletId) {
+    const fallback = getActiveWallets()[0];
+    state.activeWalletId = fallback ? fallback.id : 0;
+  }
+
+  saveWallets();
+  renderWalletList();
+  renderWalletSelector();
+  renderAccountsList();
+  updateCustomPathDefault();
+  updateWalletBondTotal();
+}
+
+function setWalletManageTab(tabName) {
+  state.walletManageTab = tabName === 'inactive' ? 'inactive' : 'active';
+
+  const activeBtn = $('wallet-manage-tab-active');
+  const inactiveBtn = $('wallet-manage-tab-inactive');
+  if (activeBtn) activeBtn.classList.toggle('active', state.walletManageTab === 'active');
+  if (inactiveBtn) inactiveBtn.classList.toggle('active', state.walletManageTab === 'inactive');
+
+  renderWalletList();
+}
+
+function renderWalletList() {
+  const listEl = $('wallet-list');
+  if (!listEl) return;
+  listEl.innerHTML = '';
+  ensureWalletNamesNormalized();
+
+  const activeWalletCount = getActiveWallets().length;
+  const walletsToRender = state.walletManageTab === 'inactive'
+    ? getInactiveWallets()
+    : getActiveWallets();
+
+  if (walletsToRender.length === 0) {
+    const empty = document.createElement('div');
+    empty.className = 'wallet-manage-empty';
+    empty.textContent = state.walletManageTab === 'inactive'
+      ? 'No inactive wallets.'
+      : 'No active wallets.';
+    listEl.appendChild(empty);
+    return;
+  }
+
+  for (const w of walletsToRender) {
+    const count = state.activeAccounts.filter(a => getAccountWalletId(a) === w.id && isSigningAccountForWallet(a, w)).length;
+    const actionLabel = isWalletInactive(w) ? 'Active' : 'Inactive';
+    const disableAction = !isWalletInactive(w) && activeWalletCount <= 1;
+    const derivationSummary = getWalletDerivationEntries(w)
+      .map(entry => buildSigningPath(entry.coinType, entry.account, entry.index))
+      .join(' • ');
+    const derivationTitle = derivationSummary.replace(/"/g, '&quot;');
+    const row = document.createElement('div');
+    row.className = 'wallet-name-row';
+    row.innerHTML =
+      '<div class="wallet-name-cell">' +
+      '<input class="wallet-name-input glass-input compact" value="' + (w.name || '').replace(/"/g, '&quot;') + '" data-wallet-id="' + w.id + '">' +
+      '<div class="wallet-derivation-path" title="' + derivationTitle + '">' + derivationSummary + '</div>' +
+      '</div>' +
+      '<span class="wallet-account-count">' + count + ' account' + (count !== 1 ? 's' : '') + '</span>' +
+      '<button class="wallet-status-btn glass-btn small' + (disableAction ? ' disabled' : '') + '" data-wallet-id="' + w.id + '" data-target-inactive="' + (!isWalletInactive(w)) + '" ' + (disableAction ? 'disabled' : '') + '>' + actionLabel + '</button>';
+    listEl.appendChild(row);
+  }
+
+  listEl.querySelectorAll('.wallet-name-input').forEach(input => {
+    input.addEventListener('change', (e) => {
+      const id = Number.parseInt(e.target.dataset.walletId, 10);
+      const wallet = getWalletById(id);
+      renameWallet(id, e.target.value.trim() || getDefaultWalletName(wallet ? wallet.accountIndex : id));
+    });
+  });
+
+  listEl.querySelectorAll('.wallet-status-btn').forEach(btn => {
+    btn.addEventListener('click', (e) => {
+      const id = Number.parseInt(e.currentTarget.dataset.walletId, 10);
+      if (Number.isNaN(id)) return;
+      const targetInactive = e.currentTarget.dataset.targetInactive === 'true';
+      setWalletInactive(id, targetInactive);
+    });
+  });
+}
+
+// --- Wallet Overlay Navigation ---
+
+function hideWalletOverlays() {
+  WALLET_OVERLAY_VIEWS.forEach((viewId) => {
+    const view = $(viewId);
+    if (view) view.style.display = 'none';
+  });
+}
+
+function showWalletMainView() {
+  const main = $('wallet-main-view');
+  hideWalletOverlays();
+  if (main) main.style.display = 'block';
+}
+
+function showWalletView(viewId) {
+  const main = $('wallet-main-view');
+  hideWalletOverlays();
+  if (main) main.style.display = 'none';
+  const view = $(viewId);
+  if (view) view.style.display = viewId === 'wallet-wallets-view' ? 'flex' : 'block';
+}
+
+function showWalletsView() {
+  showWalletView('wallet-wallets-view');
+  setWalletManageTab(state.walletManageTab);
+}
+
+function showExportView() {
+  showWalletView('wallet-export-view');
+}
+
+function showAdvancedView() {
+  showWalletView('wallet-advanced-view');
+  updateCustomPathWalletLabel();
+  updateCustomPathDefault();
+}
+
+function showSendView(preselectedIdx) {
+  showWalletView('wallet-send-view');
+  populateSendForm(preselectedIdx);
+}
+
+function hideSendView() {
+  showWalletMainView();
+  // Reset form
+  const compose = $('send-compose-step');
+  const review = $('send-review-step');
+  if (compose) compose.style.display = 'block';
+  if (review) review.style.display = 'none';
+}
+
+function addCustomPathAccount() {
+  if (!state.hdRoot) return;
+  const chainSelect = $('custom-path-chain');
+  const pathInput = $('custom-path-input');
+  if (!chainSelect || !pathInput) return;
+
+  const coinType = Number.parseInt(chainSelect.value, 10);
+  const pathStr = pathInput.value.trim();
+  if (!pathStr || Number.isNaN(coinType)) return;
+
+  // Parse account/index from path (m/44'/coin'/account'/0/index)
+  const parts = pathStr.replace(/'/g, '').split('/');
+  const account = Number.parseInt(parts[3], 10) || 0;
+  const index = Number.parseInt(parts[5], 10) || 0;
+  const wallet = getCurrentWallet();
+  const walletId = wallet ? wallet.id : 0;
+  if (!wallet) return;
+
+  const proposed = { coinType, account, index, walletId };
+  if (!isSigningAccountForWallet(proposed, wallet)) {
+    alert('Only signing-path accounts are supported for wallet availability.');
+    updateCustomPathDefault();
+    return;
+  }
+
+  const chainName = CHAIN_CONFIG.find(c => c.coinType === coinType)?.name || 'BTC';
+  const exists = state.activeAccounts.some(
+    a => getAccountWalletId(a) === walletId
+      && a.coinType === coinType
+      && a.account === account
+      && a.index === index
+  );
+  if (exists) return;
+
+  try {
+    const { address, path } = deriveAddressForPath(coinType, account, index);
+    state.activeAccounts.push({
+      coinType,
+      name: chainName,
+      account,
+      index,
+      address,
+      path,
+      balance: '--',
+      active: false,
+      walletId,
+    });
+    saveActiveAccounts();
+    renderAccountsList();
+    updateWalletBondTotal();
+    updateCustomPathDefault();
+  } catch (e) {
+    console.warn('Failed to add custom path:', e);
+  }
+}
+
+/**
+ * Merge newly scanned accounts with existing ones.
+ * Preserves user's active/inactive choices; updates balances.
+ */
+function mergeAccounts(existing, scanned) {
+  const key = (a) => `${getAccountWalletId(a)}:${a.coinType}:${a.account}:${a.index}`;
+  const map = new Map();
+
+  // Existing accounts keep their active state
+  for (const a of existing) {
+    map.set(key(a), { ...a, walletId: getAccountWalletId(a) });
+  }
+
+  // Scanned accounts update balances, add new entries
+  for (const a of scanned) {
+    const k = key(a);
+    if (map.has(k)) {
+      const prev = map.get(k);
+      prev.balance = a.balance;
+      prev.address = a.address;
+      prev.path = a.path;
+      prev.name = a.name;
+      prev.walletId = getAccountWalletId(a);
+    } else {
+      map.set(k, { ...a, walletId: getAccountWalletId(a) });
+    }
+  }
+
+  return Array.from(map.values());
+}
+
+const CHAIN_CONFIG = [
+  { coinType: 0,   name: 'BTC', fetchBalance: fetchBtcBalance },
+  { coinType: 60,  name: 'ETH', fetchBalance: fetchEthBalance },
+  { coinType: 501, name: 'SOL', fetchBalance: fetchSolBalance },
+];
+
+async function scanActiveAccounts() {
+  if (!state.hdRoot) return;
+  if (state.scanInProgress) return;
+  state.scanInProgress = true;
+
+  if (!state.balanceCacheLoaded) {
+    state.balanceCache = loadBalanceCache();
+    state.balanceCacheLoaded = true;
+  }
+  pruneBalanceCache();
+  const ensuredAccounts = ensureWalletAccounts();
+  const hydratedFromCache = hydrateAccountsFromBalanceCache();
+  if (ensuredAccounts || hydratedFromCache) {
+    renderAccountsList();
+  }
+  updateWalletBondTotal();
+
+  const statusEl = $('wallet-scan-status');
+  const labelEl = $('wallet-scan-label');
+  const scanBtn = $('wallet-scan-btn');
+  if (statusEl) statusEl.style.display = 'flex';
+  if (scanBtn) scanBtn.disabled = true;
+
+  try {
+    const found = [];
+    const chainByCoinType = new Map(CHAIN_CONFIG.map(chain => [chain.coinType, chain]));
+    const targets = [];
+    const seen = new Set();
+    const addTarget = (coinType, account, index, walletId, name) => {
+      const chain = chainByCoinType.get(coinType);
+      if (!chain) return;
+      const key = `${walletId}:${coinType}:${account}:${index}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      targets.push({
+        coinType,
+        account,
+        index,
+        walletId,
+        name: name || chain.name,
+        fetchBalance: chain.fetchBalance,
+      });
+    };
+
+    getActiveWallets().forEach((wallet) => {
+      getWalletDerivationEntries(wallet).forEach((entry) => {
+        addTarget(entry.coinType, entry.account, entry.index, wallet.id, entry.name);
+      });
+    });
+
+    for (const target of targets) {
+      if (labelEl) {
+        labelEl.textContent = `Scanning ${target.name} m/44'/${target.coinType}'/${target.account}'/0/${target.index}...`;
+      }
+
+      let derived;
+      try {
+        derived = deriveAddressForPath(target.coinType, target.account, target.index);
+      } catch (deriveErr) {
+        console.warn(`Derivation failed ${target.name} ${target.account}/${target.index}:`, deriveErr);
+        continue;
+      }
+
+      const existing = findExistingAccountForTarget(target);
+      const result = await fetchBalanceForScanTarget(target, derived.address);
+      if (!result.ok) {
+        console.warn(`Balance fetch failed ${target.name} ${target.account}/${target.index}:`, result.error);
+      }
+
+      // Never clobber a known balance with "--" when the network call fails/rate-limits.
+      const resolvedBalance = result.ok
+        ? result.balance
+        : (existing?.balance && existing.balance !== '--' ? existing.balance : '--');
+      const balNum = Number.parseFloat(resolvedBalance);
+
+      found.push({
+        coinType: target.coinType,
+        name: target.name,
+        account: target.account,
+        index: target.index,
+        address: derived.address,
+        path: derived.path,
+        balance: resolvedBalance,
+        active: Number.isFinite(balNum) ? balNum > 0 : (existing?.active || false),
+        walletId: target.walletId,
+      });
+
+      // Surface funded accounts quickly instead of waiting for full scan completion.
+      if (Number.isFinite(balNum) && balNum > 0) {
+        state.activeAccounts = mergeAccounts(state.activeAccounts, [found[found.length - 1]]).filter(isSigningAccount);
+        saveActiveAccounts();
+        renderAccountsList();
+        updateWalletBondTotal();
+      }
+    }
+
+    state.activeAccounts = mergeAccounts(state.activeAccounts, found).filter(isSigningAccount);
+    saveActiveAccounts();
+    saveBalanceCache();
+    renderAccountsList();
+    updateWalletBondTotal();
+  } finally {
+    if (statusEl) statusEl.style.display = 'none';
+    if (scanBtn) scanBtn.disabled = false;
+    state.scanInProgress = false;
+  }
+}
+
+const CHAIN_ICONS = {
+  BTC: { color: '#F7931A', symbol: '\u20BF' },
+  ETH: { color: '#627EEA', symbol: '\u039E' },
+  SOL: { color: '#9945FF', symbol: 'S' },
+};
+
+const CHAIN_FULL_NAMES = {
+  BTC: 'Bitcoin',
+  ETH: 'Ethereum',
+  SOL: 'Solana',
+};
+
+function getVisibleWalletEntries() {
+  const wallet = getCurrentWallet();
+  if (!wallet) return [];
+  const chainOrder = { BTC: 0, ETH: 1, SOL: 2 };
+  const entries = state.activeAccounts
+    .map((acct, idx) => ({ acct, idx, walletId: getAccountWalletId(acct) }))
+    .filter(entry => entry.walletId === wallet.id && isSigningAccountForWallet(entry.acct, wallet));
+
+  entries.sort((a, b) => {
+    const chainDelta = (chainOrder[a.acct.name] ?? 99) - (chainOrder[b.acct.name] ?? 99);
+    if (chainDelta !== 0) return chainDelta;
+    const accountDelta = (a.acct.account ?? 0) - (b.acct.account ?? 0);
+    if (accountDelta !== 0) return accountDelta;
+    return (a.acct.index ?? 0) - (b.acct.index ?? 0);
+  });
+  return entries;
+}
+
+function getWalletAccountForChain(chainName) {
+  const matches = getVisibleWalletEntries()
+    .map(entry => entry.acct)
+    .filter(acct => acct.name === chainName);
+  if (matches.length === 0) return null;
+
+  const funded = matches.filter(acct => (Number.parseFloat(acct.balance) || 0) > 0);
+  const activeFunded = funded.find(acct => acct.active);
+  if (activeFunded) return activeFunded;
+  if (funded.length > 0) return funded[0];
+
+  const active = matches.find(acct => acct.active);
+  if (active) return active;
+  return matches[0];
+}
+
+function updateWalletActionMenus() {
+  ['BTC', 'ETH', 'SOL'].forEach((chain) => {
+    const available = Boolean(getWalletAccountForChain(chain));
+    $qa(`.ph-action-menu-item[data-chain="${chain}"]`).forEach((btn) => {
+      btn.disabled = !available;
+      btn.title = available ? '' : `No ${chain} account in this wallet`;
+    });
+  });
+}
+
+function closeWalletActionMenus() {
+  $('wallet-send-menu')?.classList.remove('visible');
+  $('wallet-receive-menu')?.classList.remove('visible');
+}
+
+function renderAccountsList() {
+  const listEl = $('wallet-accounts-list');
+  const emptyEl = $('wallet-accounts-empty');
+  if (!listEl) return;
+
+  // Clear all dynamic content (wallet headers + token rows)
+  listEl.querySelectorAll('.ph-token-row, .ph-wallet-header').forEach(r => r.remove());
+  const entries = getVisibleWalletEntries();
+  if (entries.length === 0) {
+    if (emptyEl) emptyEl.style.display = 'flex';
+    const emptySub = emptyEl?.querySelector('.ph-token-empty-sub');
+    if (emptySub) {
+      const wallet = getCurrentWallet();
+      emptySub.textContent = wallet
+        ? `No accounts yet for ${wallet.name}. Tap Scan or add one from Advanced.`
+        : 'No accounts yet.';
+    }
+    updateWalletActionMenus();
+    return;
+  }
+
+  if (emptyEl) emptyEl.style.display = 'none';
+
+  const pricesPromise = fetchCryptoPrices(getSelectedCurrency()).catch(() => null);
+
+  for (const { acct, idx } of entries) {
+    const row = document.createElement('div');
+    row.className = 'ph-token-row' + (acct.active ? '' : ' ph-token-inactive');
+    row.dataset.idx = idx;
+
+    const bal = parseFloat(acct.balance);
+    const balDisplay = isNaN(bal) ? acct.balance : (bal > 0 ? bal.toFixed(bal < 0.001 ? 8 : 4) : '0');
+    const icon = CHAIN_ICONS[acct.name] || { color: '#888', symbol: '?' };
+    const fullName = CHAIN_FULL_NAMES[acct.name] || acct.name;
+    const pathLabel = acct.path || "m/44'/" + acct.coinType + "'/" + acct.account + "'/0/" + acct.index;
+
+    row.innerHTML =
+      '<div class="ph-token-icon" style="background:' + icon.color + '">' + icon.symbol + '</div>' +
+      '<div class="ph-token-info">' +
+        '<div class="ph-token-name">' + fullName + '</div>' +
+        '<div class="ph-token-path">' + pathLabel + '</div>' +
+      '</div>' +
+      '<div class="ph-token-amounts">' +
+        '<div class="ph-token-balance">' + balDisplay + ' ' + acct.name + '</div>' +
+        '<div class="ph-token-fiat" id="ph-fiat-' + idx + '"></div>' +
+      '</div>';
+
+    row.addEventListener('click', () => {
+      showReceiveModal(acct);
+    });
+
+    listEl.appendChild(row);
+  }
+  updateWalletActionMenus();
+
+  pricesPromise.then(prices => {
+    if (!prices) return;
+    const currency = getSelectedCurrency();
+    entries.forEach(({ acct, idx }) => {
+      const bal = parseFloat(acct.balance) || 0;
+      const priceKey = acct.name.toUpperCase();
+      const fiatVal = bal * (prices[priceKey] || 0);
+      const el = $('ph-fiat-' + idx);
+      if (el) el.textContent = fiatVal > 0 ? formatCurrencyValue(fiatVal, currency) : '';
+    });
+  });
+}
+
+function toggleAccountActive(idx) {
+  if (idx < 0 || idx >= state.activeAccounts.length) return;
+  state.activeAccounts[idx].active = !state.activeAccounts[idx].active;
+  saveActiveAccounts();
+  renderAccountsList();
+}
+
+async function handleAccountAction(action, idx) {
+  const acct = state.activeAccounts[idx];
+  if (!acct) return;
+
+  switch (action) {
+    case 'receive':
+      showReceiveModal(acct);
+      break;
+    case 'copy':
+      try {
+        await navigator.clipboard.writeText(acct.address);
+      } catch {}
+      break;
+    case 'toggle':
+      toggleAccountActive(idx);
+      break;
+    case 'remove':
+      state.activeAccounts.splice(idx, 1);
+      saveActiveAccounts();
+      renderAccountsList();
+      break;
+  }
+}
+
+async function showReceiveModal(acct) {
+  // Create a simple receive overlay
+  let overlay = $('wallet-receive-overlay');
+  if (!overlay) {
+    overlay = document.createElement('div');
+    overlay.id = 'wallet-receive-overlay';
+    overlay.className = 'wallet-receive-overlay';
+    overlay.innerHTML = `
+      <div class="wallet-receive-card">
+        <h4 id="wallet-receive-title" class="section-label"></h4>
+        <canvas id="wallet-receive-qr"></canvas>
+        <code id="wallet-receive-address" class="wallet-receive-address"></code>
+        <div class="wallet-receive-actions">
+          <button id="wallet-receive-copy" class="glass-btn small">Copy</button>
+          <button id="wallet-receive-close" class="glass-btn small">Close</button>
+        </div>
+      </div>
+    `;
+    $('wallet-tab-content')?.appendChild(overlay);
+  }
+
+  const titleEl = overlay.querySelector('#wallet-receive-title');
+  const addrEl = overlay.querySelector('#wallet-receive-address');
+  if (titleEl) titleEl.textContent = `Receive ${acct.name}`;
+  if (addrEl) addrEl.textContent = acct.address;
+
+  try {
+    const qrCanvas = overlay.querySelector('#wallet-receive-qr');
+    if (qrCanvas) {
+      await QRCode.toCanvas(qrCanvas, acct.address, {
+        width: 180,
+        margin: 2,
+        color: { dark: '#1e293b', light: '#ffffff' },
+      });
+    }
+  } catch (e) {
+    console.warn('QR generation failed:', e);
+  }
+
+  overlay.style.display = 'flex';
+
+  overlay.querySelector('#wallet-receive-copy')?.addEventListener('click', () => {
+    navigator.clipboard.writeText(acct.address).catch(() => {});
+  }, { once: true });
+
+  overlay.querySelector('#wallet-receive-close')?.addEventListener('click', () => {
+    overlay.style.display = 'none';
+  }, { once: true });
+}
+
+// =============================================================================
+// Send Flow
+// =============================================================================
+
+function populateSendForm(preselectedIdx) {
+  const select = $('send-from-account');
+  if (!select) return;
+  select.innerHTML = '';
+
+  const walletEntries = getVisibleWalletEntries();
+  const walletAccounts = walletEntries.map(entry => entry.acct);
+  const activeAccts = walletAccounts.filter(a => a.active || parseFloat(a.balance) > 0);
+  const accts = activeAccts.length > 0 ? [...activeAccts] : [...walletAccounts];
+  const preselectedAcct = typeof preselectedIdx === 'number' ? state.activeAccounts[preselectedIdx] : null;
+  if (preselectedAcct && walletAccounts.includes(preselectedAcct) && !accts.includes(preselectedAcct)) {
+    accts.unshift(preselectedAcct);
+  }
+
+  accts.forEach((acct) => {
+    const opt = document.createElement('option');
+    const origIdx = state.activeAccounts.indexOf(acct);
+    opt.value = origIdx;
+    const bal = parseFloat(acct.balance);
+    const balStr = isNaN(bal) ? '' : (' — ' + bal.toFixed(bal < 0.001 ? 8 : 4) + ' ' + acct.name);
+    opt.textContent = acct.name + ' ' + truncateAddress(acct.address) + balStr;
+    select.appendChild(opt);
+  });
+
+  if (typeof preselectedIdx === 'number') {
+    select.value = String(preselectedIdx);
+  }
+
+  if (select.options.length > 0) {
+    updateSendFromSelection();
+  } else {
+    const balEl = $('send-available-balance');
+    const labelEl = $('send-currency-label');
+    if (balEl) balEl.textContent = '--';
+    if (labelEl) labelEl.textContent = '--';
+  }
+
+  // Reset review step
+  const compose = $('send-compose-step');
+  const review = $('send-review-step');
+  if (compose) compose.style.display = 'block';
+  if (review) review.style.display = 'none';
+  const statusEl = $('send-status');
+  if (statusEl) statusEl.style.display = 'none';
+
+  // Clear inputs
+  const toAddr = $('send-to-address');
+  const amount = $('send-amount');
+  if (toAddr) toAddr.value = '';
+  if (amount) amount.value = '';
+  const fiatEst = $('send-fiat-estimate');
+  if (fiatEst) fiatEst.textContent = '';
+  const reviewBtn = $('send-review-btn');
+  if (reviewBtn) reviewBtn.disabled = true;
+}
+
+function updateSendFromSelection() {
+  const select = $('send-from-account');
+  if (!select) return;
+  const idx = parseInt(select.value);
+  const acct = state.activeAccounts[idx];
+  if (!acct) return;
+
+  const balEl = $('send-available-balance');
+  const labelEl = $('send-currency-label');
+  if (balEl) {
+    const bal = parseFloat(acct.balance);
+    balEl.textContent = (isNaN(bal) ? acct.balance : bal.toFixed(bal < 0.001 ? 8 : 4)) + ' ' + acct.name;
+  }
+  if (labelEl) labelEl.textContent = acct.name;
+}
+
+function validateSendForm() {
+  const select = $('send-from-account');
+  const toAddr = $('send-to-address');
+  const amount = $('send-amount');
+  const reviewBtn = $('send-review-btn');
+  if (!select || !toAddr || !amount || !reviewBtn) return;
+
+  const idx = parseInt(select.value);
+  const acct = state.activeAccounts[idx];
+  const addr = toAddr.value.trim();
+  const amt = parseFloat(amount.value);
+
+  reviewBtn.disabled = !(acct && addr.length > 10 && amt > 0);
+}
+
+function showSendReview() {
+  const select = $('send-from-account');
+  const toAddr = $('send-to-address');
+  const amount = $('send-amount');
+  if (!select || !toAddr || !amount) return;
+
+  const idx = parseInt(select.value);
+  const acct = state.activeAccounts[idx];
+  if (!acct) return;
+
+  const amt = parseFloat(amount.value);
+  const fee = acct.name === 'BTC' ? 0.0001 : (acct.name === 'ETH' ? 0.002 : 0.000005);
+
+  const reviewTo = $('send-review-to');
+  const reviewAmt = $('send-review-amount');
+  const reviewFee = $('send-review-fee');
+  const reviewTotal = $('send-review-total');
+
+  if (reviewTo) reviewTo.textContent = toAddr.value.trim();
+  if (reviewAmt) reviewAmt.textContent = amt.toFixed(amt < 0.001 ? 8 : 4) + ' ' + acct.name;
+  if (reviewFee) reviewFee.textContent = '~' + fee + ' ' + acct.name;
+  if (reviewTotal) reviewTotal.textContent = (amt + fee).toFixed(8) + ' ' + acct.name;
+
+  const compose = $('send-compose-step');
+  const review = $('send-review-step');
+  if (compose) compose.style.display = 'none';
+  if (review) review.style.display = 'block';
+}
+
+async function executeSend() {
+  const select = $('send-from-account');
+  const toAddr = $('send-to-address');
+  const amount = $('send-amount');
+  const statusEl = $('send-status');
+  const confirmBtn = $('send-confirm-btn');
+
+  if (!select || !toAddr || !amount) return;
+
+  const idx = parseInt(select.value);
+  const acct = state.activeAccounts[idx];
+  if (!acct) return;
+
+  const to = toAddr.value.trim();
+  const amt = parseFloat(amount.value);
+
+  if (statusEl) {
+    statusEl.style.display = 'block';
+    statusEl.className = 'send-status send-status-pending';
+    statusEl.textContent = 'Broadcasting transaction...';
+  }
+  if (confirmBtn) confirmBtn.disabled = true;
+
+  try {
+    let txHash;
+
+    if (acct.coinType === 0) {
+      txHash = await sendBtcTransaction(acct, to, amt);
+    } else if (acct.coinType === 60) {
+      txHash = await sendEthTransaction(acct, to, amt);
+    } else if (acct.coinType === 501) {
+      txHash = await sendSolTransaction(acct, to, amt);
+    } else {
+      throw new Error('Unsupported chain: ' + acct.name);
+    }
+
+    if (statusEl) {
+      statusEl.className = 'send-status send-status-success';
+      statusEl.innerHTML = 'Transaction sent! Hash: <code class="truncate">' + (txHash || 'pending') + '</code>';
+    }
+
+    // Refresh balances after a short delay
+    setTimeout(() => {
+      scanActiveAccounts();
+    }, 5000);
+  } catch (e) {
+    console.error('Send failed:', e);
+    if (statusEl) {
+      statusEl.className = 'send-status send-status-error';
+      statusEl.textContent = 'Failed: ' + (e.message || 'Unknown error');
+    }
+  } finally {
+    if (confirmBtn) confirmBtn.disabled = false;
+  }
+}
+
+// --- Per-chain transaction construction ---
+
+async function sendBtcTransaction(acct, toAddress, amountBtc) {
+  const module = state.hdWalletModule;
+  if (!module?.bitcoin?.tx) throw new Error('Bitcoin tx builder not available');
+
+  // Fetch UTXOs
+  const utxoResp = await fetch(apiUrl('https://blockchain.info/unspent?active=' + acct.address));
+  if (!utxoResp.ok) throw new Error('Failed to fetch UTXOs (address may have no unspent outputs)');
+  const utxoData = await utxoResp.json();
+  const utxos = utxoData.unspent_outputs || [];
+  if (utxos.length === 0) throw new Error('No UTXOs available');
+
+  const amountSats = BigInt(Math.round(amountBtc * 1e8));
+  const feeSats = BigInt(10000); // ~0.0001 BTC flat fee estimate
+  const totalNeeded = amountSats + feeSats;
+
+  // Select UTXOs (simple greedy)
+  let inputSum = BigInt(0);
+  const selectedUtxos = [];
+  for (const utxo of utxos) {
+    selectedUtxos.push(utxo);
+    inputSum += BigInt(utxo.value);
+    if (inputSum >= totalNeeded) break;
+  }
+  if (inputSum < totalNeeded) throw new Error('Insufficient funds');
+
+  // Build transaction
+  const tx = module.bitcoin.tx.create();
+  for (const utxo of selectedUtxos) {
+    tx.addInput(utxo.tx_hash_big_endian, utxo.tx_output_n);
+  }
+  tx.addOutput(toAddress, amountSats);
+
+  // Change output
+  const change = inputSum - amountSats - feeSats;
+  if (change > BigInt(546)) { // dust threshold
+    tx.addOutput(acct.address, change);
+  }
+
+  // Sign each input
+  const path = acct.path || buildSigningPath(acct.coinType, acct.account, acct.index);
+  const derived = state.hdRoot.derivePath(path);
+  const privKey = derived.privateKey();
+  for (let i = 0; i < selectedUtxos.length; i++) {
+    tx.sign(i, privKey);
+  }
+
+  const rawTx = tx.serialize();
+  const hexTx = Array.from(rawTx).map(b => b.toString(16).padStart(2, '0')).join('');
+
+  // Broadcast
+  const broadcastResp = await fetch(apiUrl('https://blockchain.info/pushtx'), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: 'tx=' + hexTx,
+  });
+  if (!broadcastResp.ok) {
+    const errText = await broadcastResp.text();
+    throw new Error('Broadcast failed: ' + errText);
+  }
+
+  return tx.getTxid();
+}
+
+async function sendEthTransaction(acct, toAddress, amountEth) {
+  const module = state.hdWalletModule;
+  if (!module?.ethereum?.tx) throw new Error('Ethereum tx builder not available');
+
+  const ETH_RPC = 'https://cloudflare-eth.com';
+  const rpc = async (method, params) => {
+    const resp = await fetch(ETH_RPC, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+    });
+    const data = await resp.json();
+    if (data.error) throw new Error(data.error.message);
+    return data.result;
+  };
+
+  // Get nonce, gas price, estimate gas
+  const [nonceHex, baseFeeBlock] = await Promise.all([
+    rpc('eth_getTransactionCount', [acct.address, 'latest']),
+    rpc('eth_getBlockByNumber', ['latest', false]),
+  ]);
+
+  const nonce = parseInt(nonceHex, 16);
+  const baseFee = BigInt(baseFeeBlock.baseFeePerGas || '0x0');
+  const maxPriorityFee = BigInt(2000000000); // 2 gwei
+  const maxFee = baseFee * BigInt(2) + maxPriorityFee;
+  const gasLimit = BigInt(21000);
+
+  // Convert ETH to wei
+  const weiStr = BigInt(Math.round(amountEth * 1e18));
+
+  const tx = module.ethereum.tx.createEIP1559({
+    nonce,
+    maxFeePerGas: maxFee,
+    maxPriorityFeePerGas: maxPriorityFee,
+    gasLimit,
+    to: toAddress,
+    value: weiStr,
+    chainId: 1,
+  });
+
+  // Sign
+  const path = acct.path || buildSigningPath(acct.coinType, acct.account, acct.index);
+  const derived = state.hdRoot.derivePath(path);
+  const privKey = derived.privateKey();
+  tx.sign(privKey);
+
+  const rawTx = tx.serialize();
+  const hexTx = '0x' + Array.from(rawTx).map(b => b.toString(16).padStart(2, '0')).join('');
+
+  // Broadcast
+  const txHash = await rpc('eth_sendRawTransaction', [hexTx]);
+  return txHash;
+}
+
+async function sendSolTransaction(acct, toAddress, amountSol) {
+  // Solana transfer via RPC (no WASM builder — manual SystemProgram.transfer)
+  const SOL_ENDPOINTS = [
+    'https://api.mainnet-beta.solana.com',
+    'https://solana-mainnet.g.alchemy.com/v2/demo',
+    'https://rpc.ankr.com/solana',
+  ];
+
+  const rpc = async (method, params) => {
+    for (const endpoint of SOL_ENDPOINTS) {
+      try {
+        const resp = await fetch(endpoint, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+        });
+        const data = await resp.json();
+        if (data.error) throw new Error(data.error.message);
+        return data.result;
+      } catch (e) {
+        continue;
+      }
+    }
+    throw new Error('All Solana RPC endpoints failed');
+  };
+
+  // For Solana, we need @solana/web3.js which may not be available
+  // Try dynamic import, otherwise fail gracefully
+  throw new Error('Solana send requires @solana/web3.js (not yet integrated). Use a Solana wallet to send SOL.');
+}
+
+async function updateSendFiatEstimate() {
+  const select = $('send-from-account');
+  const amount = $('send-amount');
+  const fiatEst = $('send-fiat-estimate');
+  if (!select || !amount || !fiatEst) return;
+
+  const idx = parseInt(select.value);
+  const acct = state.activeAccounts[idx];
+  if (!acct) return;
+
+  const amt = parseFloat(amount.value) || 0;
+  if (amt <= 0) { fiatEst.textContent = ''; return; }
+
+  try {
+    const currency = getSelectedCurrency();
+    const prices = await fetchCryptoPrices(currency);
+    const price = prices[acct.name.toUpperCase()] || 0;
+    const fiat = amt * price;
+    fiatEst.textContent = fiat > 0 ? '~ ' + formatCurrencyValue(fiat, currency) : '';
+  } catch {
+    fiatEst.textContent = '';
+  }
+}
+
+async function updateWalletBondTotal() {
+  const valueEl = $('wallet-bond-value');
+
+  try {
+    const currency = getSelectedCurrency();
+    const prices = await fetchCryptoPrices(currency);
+
+    let total = 0;
+    const walletTotals = {};
+    let hasPositiveBalance = false;
+    let missingPriceForFundedAccount = false;
+    for (const acct of state.activeAccounts.filter(isSigningAccount)) {
+      const bal = Number.parseFloat(acct.balance);
+      if (!Number.isFinite(bal) || bal <= 0) continue;
+      hasPositiveBalance = true;
+
+      const priceKey = acct.name.toUpperCase();
+      const price = Number.parseFloat(prices[priceKey]);
+      if (!Number.isFinite(price) || price <= 0) {
+        missingPriceForFundedAccount = true;
+        continue;
+      }
+
+      const fiatValue = bal * price;
+      total += fiatValue;
+      const walletId = getAccountWalletId(acct);
+      walletTotals[walletId] = (walletTotals[walletId] || 0) + fiatValue;
+    }
+
+    if (hasPositiveBalance && total <= 0 && missingPriceForFundedAccount) {
+      throw new Error('Funded accounts found but fiat pricing is unavailable');
+    }
+
+    state.walletFiatTotals = walletTotals;
+    state.walletFiatCurrency = currency;
+
+    const formatted = formatCurrencyValue(total, currency);
+    if (valueEl) valueEl.textContent = formatted;
+    renderWalletSelector();
+
+    // Also update the header bond total
+    const accountTotalEl = $('account-total-value');
+    if (accountTotalEl) {
+      accountTotalEl.textContent = 'Bond: ' + formatted;
+    }
+  } catch (e) {
+    console.warn('Bond total calculation failed:', e);
+    // Keep last known totals if pricing endpoint is temporarily unavailable.
+    const cachedTotals = state.walletFiatTotals || {};
+    const cachedTotal = Object.values(cachedTotals).reduce((sum, v) => sum + (Number.isFinite(v) ? v : 0), 0);
+    if (cachedTotal > 0) {
+      const displayCurrency = state.walletFiatCurrency || getSelectedCurrency();
+      const formatted = formatCurrencyValue(cachedTotal, displayCurrency);
+      if (valueEl) valueEl.textContent = formatted;
+      const accountTotalEl = $('account-total-value');
+      if (accountTotalEl) accountTotalEl.textContent = 'Bond: ' + formatted;
+    } else if (valueEl && !valueEl.textContent) {
+      valueEl.textContent = '$0.00';
+    }
+    renderWalletSelector();
+  }
+}
+
+
 async function deriveAndDisplayAddress() {
   console.log('deriveAndDisplayAddress called, hdRoot:', !!state.hdRoot);
 
@@ -851,9 +2409,10 @@ function login(keys) {
     if (xpubEl) {
       setTruncatedValue(xpubEl, state.hdRoot.toXpub() || 'N/A');
     }
-    const keysXpubEl = $('keys-xpub');
-    if (keysXpubEl) {
-      setTruncatedValue(keysXpubEl, state.hdRoot.toXpub() || 'N/A');
+    // Populate wallet tab xpub display
+    const walletTabXpubEl = $('wallet-tab-xpub');
+    if (walletTabXpubEl) {
+      setTruncatedValue(walletTabXpubEl, state.hdRoot.toXpub() || 'N/A');
     }
     populateAccountAddressDropdown();
     if (xprvEl) {
@@ -866,6 +2425,22 @@ function login(keys) {
     } else if (seedEl) {
       seedEl.textContent = 'Not available (derived from password)';
     }
+
+    // Load persisted wallets and active accounts
+    state.wallets = loadWallets();
+    state.activeAccounts = normalizeActiveAccounts(loadActiveAccounts());
+    const currentWallet = getCurrentWallet() || getActiveWallets()[0] || state.wallets[0];
+    state.activeWalletId = currentWallet ? currentWallet.id : 0;
+    ensureWalletAccounts();
+    state.activeAccounts = state.activeAccounts.filter(isSigningAccount);
+    saveActiveAccounts();
+    saveWallets();
+    renderAccountsList();
+    renderWalletSelector();
+    updateCustomPathDefault();
+
+    // Auto-scan for funded accounts in the background
+    scanActiveAccounts().catch(e => console.warn('Auto-scan failed:', e));
   }
 
   // Derive PKI keys from HD wallet if available
@@ -908,12 +2483,8 @@ function login(keys) {
   // Update wallet addresses and balances
   updateAdversarialSecurity();
 
-  // Populate vCard keys display
-  populateVCardKeysDisplay();
-
   // Open Account modal so user can see the wallet they just loaded
   $('keys-modal')?.classList.add('active');
-  deriveAndDisplayAddress();
 
   // Resolve names and update title
   clearNameCache();
@@ -1000,7 +2571,7 @@ async function exportWallet(format) {
       break;
 
     case 'xpub':
-      if (!state.hdRoot?.publicExtendedKey) {
+      if (!state.hdRoot?.toXpub) {
         alert('Extended public key not available.');
         return;
       }
@@ -1010,7 +2581,7 @@ async function exportWallet(format) {
       break;
 
     case 'xprv':
-      if (!state.hdRoot?.privateExtendedKey) {
+      if (!state.hdRoot?.toXprv) {
         alert('Extended private key not available.');
         return;
       }
@@ -1060,104 +2631,26 @@ function downloadData(data, filename, mimeType) {
 // Wallet Address Population & Balance Fetching
 // =============================================================================
 
-// Account address dropdown — populated once after login, updated when balances arrive
-let _accountAddressData = {}; // { xpub: { addr, value }, btc: { addr, value }, ... }
-
+// Account header — show xpub only
 function populateAccountAddressDropdown() {
-  const sel = $('account-address-select');
-  if (!sel) return;
+  const addrEl = $('account-address-display');
+  if (!addrEl) return;
 
   const xpubStr = state.hdRoot ? state.hdRoot.toXpub() : '';
-  const addrs = state.addresses || {};
-
-  const networks = [
-    { key: 'xpub', label: 'xpub', addr: xpubStr },
-    { key: 'btc',  label: 'Bitcoin',  addr: addrs.btc || '' },
-    { key: 'eth',  label: 'Ethereum', addr: addrs.eth || '' },
-    { key: 'sol',  label: 'Solana',   addr: addrs.sol || '' },
-    // { key: 'xrp',  label: 'Ripple',   addr: addrs.xrp || '' },
-  ];
-
-  // // Add SUI/Monad/ADA if we can derive them
-  // if (state.hdRoot) {
-  //   try {
-  //     const suiPath = buildSigningPath(784, 0, 0);
-  //     const suiDerived = state.hdRoot.derivePath(suiPath);
-  //     const suiPubKey = ed25519.getPublicKey(suiDerived.privateKey());
-  //     networks.push({ key: 'sui', label: 'SUI', addr: deriveSuiAddress(suiPubKey, 'ed25519') });
-  //   } catch (_) {}
-  //   networks.push({ key: 'monad', label: 'Monad', addr: addrs.eth || '' });
-  //   try {
-  //     const adaPath = buildSigningPath(1815, 0, 0);
-  //     const adaDerived = state.hdRoot.derivePath(adaPath);
-  //     const adaPubKey = ed25519.getPublicKey(adaDerived.privateKey());
-  //     networks.push({ key: 'ada', label: 'Cardano', addr: deriveCardanoAddress(adaPubKey) });
-  //   } catch (_) {}
-  // }
-
-  _accountAddressData = {};
-  sel.innerHTML = '';
-  for (const n of networks) {
-    if (!n.addr) continue;
-    _accountAddressData[n.key] = { addr: n.addr, value: '' };
-    const opt = document.createElement('option');
-    opt.value = n.key;
-    opt.textContent = n.label;
-    sel.appendChild(opt);
-  }
-
-  sel.removeEventListener('change', updateAccountAddressDisplay);
-  sel.addEventListener('change', updateAccountAddressDisplay);
+  addrEl.textContent = `${xpubStr.slice(0,10)}...${xpubStr.slice(-10)}`;
+  addrEl.title = xpubStr;
 
   const copyBtn = $('account-address-copy');
   if (copyBtn) {
     copyBtn.onclick = () => {
-      const key = sel.value;
-      const data = _accountAddressData[key];
-      if (data?.addr) {
-        navigator.clipboard.writeText(data.addr).then(() => {
+      if (xpubStr) {
+        navigator.clipboard.writeText(xpubStr).then(() => {
           copyBtn.title = 'Copied!';
-          setTimeout(() => { copyBtn.title = 'Copy address'; }, 1500);
+          setTimeout(() => { copyBtn.title = 'Copy xpub'; }, 1500);
         });
       }
     };
   }
-
-  updateAccountAddressDisplay();
-}
-
-function updateAccountAddressDisplay() {
-  const sel = $('account-address-select');
-  const addrEl = $('account-address-display');
-  const valEl = $('account-address-value');
-  if (!sel || !addrEl) return;
-
-  const key = sel.value;
-  const data = _accountAddressData[key];
-  if (!data) return;
-
-  const addr = data.addr;
-  addrEl.textContent = addr;
-  addrEl.title = addr;
-  if (valEl) valEl.textContent = data.value || (key !== 'xpub' ? '$0.00' : '');
-}
-
-function updateAccountAddressValues(bondBalances, prices, currency) {
-  const symbol = CURRENCY_SYMBOLS[currency] || currency;
-  const keyToSymbol = { btc: 'BTC', eth: 'ETH', sol: 'SOL' };
-
-  for (const [key, data] of Object.entries(_accountAddressData)) {
-    if (key === 'xpub') {
-      data.value = '';
-      continue;
-    }
-    const sym = keyToSymbol[key];
-    const bal = parseFloat(bondBalances[key]) || 0;
-    const price = (prices && sym) ? (prices[sym] || 0) : 0;
-    const converted = bal * price;
-    data.value = converted > 0 ? symbol + converted.toFixed(2) : bal > 0 ? bal.toFixed(6) + ' ' + (sym || '') : '';
-  }
-  updateAccountAddressDisplay();
 }
 
 function populateWalletAddresses() {
@@ -1258,8 +2751,33 @@ const CURRENCY_SYMBOLS = {
 
 const CURRENCY_OPTIONS = Object.keys(CURRENCY_SYMBOLS);
 
+const PRICE_CACHE_KEY = 'hd-wallet-price-cache-v1';
+const PRICE_CACHE_TTL_MS = 60 * 1000;
+const PRICE_CACHE_STALE_MS = 30 * 60 * 1000;
 let priceCache = { data: null, currency: null, timestamp: 0 };
 
+function loadStoredPriceCache() {
+  try {
+    const raw = localStorage.getItem(PRICE_CACHE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return null;
+    if (typeof parsed.currency !== 'string' || typeof parsed.timestamp !== 'number') return null;
+    if (!parsed.data || typeof parsed.data !== 'object') return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function saveStoredPriceCache(entry) {
+  try {
+    localStorage.setItem(PRICE_CACHE_KEY, JSON.stringify(entry));
+  } catch (e) {
+    console.warn('Failed to save price cache:', e);
+  }
+}
+
 function getSelectedCurrency() {
   return localStorage.getItem('bond-currency') || 'USD';
 }
@@ -1270,12 +2788,23 @@ function setSelectedCurrency(currency) {
 
 async function fetchCryptoPrices(currency) {
   const now = Date.now();
-  if (priceCache.data && priceCache.currency === currency && now - priceCache.timestamp < 60000) {
+  if (priceCache.data && priceCache.currency === currency && now - priceCache.timestamp < PRICE_CACHE_TTL_MS) {
     return priceCache.data;
   }
 
+  const stored = loadStoredPriceCache();
+  if (stored && stored.currency === currency && now - stored.timestamp < PRICE_CACHE_TTL_MS) {
+    priceCache = { data: stored.data, currency: stored.currency, timestamp: stored.timestamp };
+    return stored.data;
+  }
+
   const cryptos = ['BTC', 'ETH', 'SOL'];
   const prices = {};
+  const setPrice = (symbol, rawValue) => {
+    const value = Number.parseFloat(rawValue);
+    if (!Number.isFinite(value) || value <= 0) return;
+    prices[symbol] = value;
+  };
 
   if (currency === 'BTC') {
     // For BTC denomination, fetch each crypto's price in BTC
@@ -1285,31 +2814,70 @@ async function fetchCryptoPrices(currency) {
       others.map(async (crypto) => {
         const url = apiUrl(`https://api.coinbase.com/v2/exchange-rates?currency=${crypto}`);
         const res = await fetch(url);
+        if (!res.ok) throw new Error(`Coinbase HTTP ${res.status}`);
         const json = await res.json();
-        return { crypto, rate: parseFloat(json.data?.rates?.BTC) || 0 };
+        return { crypto, rate: json.data?.rates?.BTC };
       })
     );
     results.forEach(r => {
-      if (r.status === 'fulfilled') prices[r.value.crypto] = r.value.rate;
+      if (r.status === 'fulfilled') setPrice(r.value.crypto, r.value.rate);
     });
-    // prices.MONAD = 0; // Testnet token, no market price
   } else {
-    // Fetch exchange rates with USD as base, then convert
+    // Fetch fiat spot prices for each supported chain coin.
     const results = await Promise.allSettled(
       cryptos.map(async (crypto) => {
         const url = apiUrl(`https://api.coinbase.com/v2/prices/${crypto}-${currency}/spot`);
         const res = await fetch(url);
+        if (!res.ok) throw new Error(`Coinbase HTTP ${res.status}`);
         const json = await res.json();
-        return { crypto, price: parseFloat(json.data?.amount) || 0 };
+        return { crypto, price: json.data?.amount };
       })
     );
     results.forEach(r => {
-      if (r.status === 'fulfilled') prices[r.value.crypto] = r.value.price;
+      if (r.status === 'fulfilled') setPrice(r.value.crypto, r.value.price);
     });
-    // prices.MONAD = 0;
+  }
+
+  // Secondary provider fallback when Coinbase is unavailable/rate-limited.
+  if (Object.keys(prices).length < cryptos.length) {
+    const missing = cryptos.filter(symbol => !Number.isFinite(prices[symbol]) || prices[symbol] <= 0);
+    if (missing.length > 0) {
+      try {
+        const vs = currency.toLowerCase();
+        const geckoUrl = apiUrl(`https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum,solana&vs_currencies=${vs}`);
+        const geckoRes = await fetch(geckoUrl);
+        if (geckoRes.ok) {
+          const gecko = await geckoRes.json();
+          const idBySymbol = { BTC: 'bitcoin', ETH: 'ethereum', SOL: 'solana' };
+          missing.forEach((symbol) => {
+            const id = idBySymbol[symbol];
+            if (!id) return;
+            setPrice(symbol, gecko?.[id]?.[vs]);
+          });
+        }
+      } catch (e) {
+        console.warn('CoinGecko price fallback failed:', e);
+      }
+    }
+  }
+
+  const hasAnyPrice = cryptos.some(symbol => Number.isFinite(prices[symbol]) && prices[symbol] > 0);
+  if (!hasAnyPrice) {
+    const staleSources = [priceCache, stored].filter(entry =>
+      entry?.data
+      && entry.currency === currency
+      && now - entry.timestamp < PRICE_CACHE_STALE_MS
+    );
+    if (staleSources.length > 0) {
+      const stale = staleSources[0];
+      priceCache = { data: stale.data, currency: stale.currency, timestamp: stale.timestamp };
+      return stale.data;
+    }
+    throw new Error(`No ${currency} prices available`);
   }
 
   priceCache = { data: prices, currency, timestamp: now };
+  saveStoredPriceCache(priceCache);
   return prices;
 }
 
@@ -1495,142 +3063,11 @@ function initCurrencySelector() {
 // =============================================================================
 
 async function updateAdversarialSecurity() {
-  const loginRequired = $('adversarial-login-required');
-  const balancesSection = $('adversarial-balances');
-
   const hasWallet = state.wallet && (state.wallet.secp256k1 || state.wallet.ed25519);
+  if (!hasWallet) return;
 
-  if (!hasWallet) {
-    if (loginRequired) loginRequired.style.display = 'block';
-    if (balancesSection) balancesSection.style.display = 'none';
-    const trustNote = $('trust-note');
-    if (trustNote) trustNote.textContent = 'Login to derive addresses and check balances.';
-    return;
-  }
-
-  if (loginRequired) loginRequired.style.display = 'none';
-  if (balancesSection) balancesSection.style.display = 'block';
-
-  populateWalletAddresses();
-
-  const btcAddress = state.addresses?.btc;
-  const ethAddress = state.addresses?.eth;
-  const solAddress = state.addresses?.sol;
-
-  // let suiAddress = null;
-  // let adaAddress = null;
-  // if (state.hdRoot) {
-  //   try {
-  //     const suiPath = buildSigningPath(784, 0, 0);
-  //     const suiDerived = state.hdRoot.derivePath(suiPath);
-  //     const suiPubKey = ed25519.getPublicKey(suiDerived.privateKey());
-  //     suiAddress = deriveSuiAddress(suiPubKey, 'ed25519');
-  //   } catch (e) { console.error('SUI derivation error:', e); }
-
-  //   try {
-  //     const adaPath = buildSigningPath(1815, 0, 0);
-  //     const adaDerived = state.hdRoot.derivePath(adaPath);
-  //     const adaPubKey = ed25519.getPublicKey(adaDerived.privateKey());
-  //     adaAddress = deriveCardanoAddress(adaPubKey);
-  //   } catch (e) { console.error('ADA derivation error:', e); }
-  // }
-
-  // const monadAddress = ethAddress;
-  // const xrpAddress = state.addresses?.xrp;
-
-  // Set loading state
-  const networks = ['btc', 'eth', 'sol'];
-  networks.forEach(net => {
-    const balEl = $(`wallet-${net}-balance`);
-    if (balEl) balEl.textContent = '...';
-  });
-  const trustNote = $('trust-note');
-  if (trustNote) trustNote.textContent = 'Fetching balances from blockchain...';
-
-  const fetchResults = await Promise.allSettled([
-    btcAddress ? fetchBtcBalance(btcAddress) : Promise.resolve({ balance: '0' }),
-    ethAddress ? fetchEthBalance(ethAddress) : Promise.resolve({ balance: '0' }),
-    solAddress ? fetchSolBalance(solAddress) : Promise.resolve({ balance: '0' }),
-    // suiAddress ? fetchSuiBalance(suiAddress) : Promise.resolve({ balance: '0' }),
-    // monadAddress ? fetchMonadBalance(monadAddress) : Promise.resolve({ balance: '0' }),
-    // adaAddress ? fetchAdaBalance(adaAddress) : Promise.resolve({ balance: '0' }),
-    // xrpAddress ? fetchXrpBalance(xrpAddress) : Promise.resolve({ balance: '0' }),
-  ]);
-
-  const [btcResult, ethResult, solResult] = fetchResults.map(
-    r => r.status === 'fulfilled' ? r.value : { balance: '0' }
-  );
-
-  const updateBalance = (network, balance, decimals = 4) => {
-    const balEl = $(`wallet-${network}-balance`);
-    if (balEl) {
-      const val = parseFloat(balance) || 0;
-      balEl.textContent = val > 0 ? val.toFixed(val < 0.0001 ? 8 : decimals) : '0';
-    }
-
-    const card = $(`wallet-${network}-card`);
-    if (card) {
-      const hasBalance = parseFloat(balance) > 0;
-      card.classList.toggle('has-balance', hasBalance);
-      card.classList.toggle('secure', hasBalance);
-    }
-  };
-
-  updateBalance('btc', btcResult.balance, 8);
-  updateBalance('eth', ethResult.balance, 6);
-  updateBalance('sol', solResult.balance, 6);
-  // updateBalance('sui', suiResult.balance, 4);
-  // updateBalance('monad', monadResult.balance, 4);
-  // updateBalance('ada', adaResult.balance, 6);
-  // updateBalance('xrp', xrpResult.balance, 6);
-
-  // Update bond tab per-network balances
-  const bondBalances = {
-    btc: btcResult.balance, eth: ethResult.balance, sol: solResult.balance,
-    // sui: suiResult.balance, monad: monadResult.balance, ada: adaResult.balance,
-    // xrp: xrpResult.balance,
-  };
-  Object.entries(bondBalances).forEach(([net, bal]) => {
-    const el = $(`bond-${net}-balance`);
-    const card = $(`bond-${net}-card`);
-    const val = parseFloat(bal) || 0;
-    if (el) el.textContent = val > 0 ? val.toFixed(val < 0.0001 ? 8 : 4) : '0';
-    if (card) card.classList.toggle('has-balance', val > 0);
-  });
-
-  // Convert to selected currency
-  const currency = getSelectedCurrency();
-  let totalConverted = 0;
-  let cryptoPrices = null;
-
-  try {
-    cryptoPrices = await fetchCryptoPrices(currency);
-    const prices = cryptoPrices;
-    const balances = {
-      BTC: parseFloat(btcResult.balance) || 0,
-      ETH: parseFloat(ethResult.balance) || 0,
-      SOL: parseFloat(solResult.balance) || 0,
-      // SUI: parseFloat(suiResult.balance) || 0,
-      // MONAD: parseFloat(monadResult.balance) || 0,
-      // ADA: parseFloat(adaResult.balance) || 0,
-      // XRP: parseFloat(xrpResult.balance) || 0,
-    };
-
-    for (const [crypto, bal] of Object.entries(balances)) {
-      totalConverted += bal * (prices[crypto] || 0);
-    }
-  } catch (e) {
-    console.warn('Price conversion failed:', e);
-  }
-
-  // Update account header total value
-  const accountTotalEl = $('account-total-value');
-  if (accountTotalEl) {
-    accountTotalEl.textContent = 'Bond: ' + formatCurrencyValue(totalConverted, currency);
-  }
-
-  // Update account address dropdown values
-  updateAccountAddressValues(bondBalances, cryptoPrices, currency);
+  // Wallet tab bond total is now updated by scanActiveAccounts/updateWalletBondTotal
+  updateWalletBondTotal();
 }
 
 // =============================================================================
@@ -1638,7 +3075,7 @@ async function updateAdversarialSecurity() {
 // =============================================================================
 
 function generateVCard(info, { skipPhoto = false } = {}) {
-  const person = {};
+  const person = { KEY: [] };
 
   if (info.firstName || info.lastName) {
     if (info.lastName) person.FAMILY_NAME = info.lastName;
@@ -1648,8 +3085,15 @@ function generateVCard(info, { skipPhoto = false } = {}) {
     if (info.suffix) person.HONORIFIC_SUFFIX = info.suffix;
   }
 
+  const contacts = [];
   if (info.email) {
-    person.CONTACT_POINT = [{ EMAIL: info.email }];
+    contacts.push({ EMAIL: info.email, CONTACT_TYPE: 'HOME' });
+  }
+  if (info.phone) {
+    contacts.push({ TELEPHONE: info.phone, CONTACT_TYPE: 'CELL' });
+  }
+  if (contacts.length) {
+    person.CONTACT_POINT = contacts;
   }
 
   if (info.org) {
@@ -1664,34 +3108,57 @@ function generateVCard(info, { skipPhoto = false } = {}) {
     person.IMAGE = state.vcardPhoto;
   }
 
-  if (info.includeKeys && state.wallet.x25519) {
+  if (info.includeKeys && state.wallet?.x25519) {
     person.KEY = [
-      ...(state.hdRoot?.publicExtendedKey ? [{
-        KEY_TYPE: 'xpub',
-        PUBLIC_KEY: state.hdRoot.toXpub(),
+      // Always include xPub
+      ...(state.hdRoot?.toXpub ? [{
+        XPUB: state.hdRoot.toXpub(),
+        LABEL: '',
       }] : []),
+      // X25519 encryption key
       {
-        KEY_TYPE: 'X25519',
         PUBLIC_KEY: toBase64(state.wallet.x25519.publicKey),
+        LABEL: 'X25519',
       },
-      {
-        KEY_TYPE: 'Ed25519',
-        PUBLIC_KEY: toBase64(state.wallet.ed25519.publicKey),
-      },
-      {
-        KEY_TYPE: 'secp256k1',
-        PUBLIC_KEY: toBase64(state.wallet.secp256k1.publicKey),
-        CRYPTO_ADDRESS: state.addresses.btc || undefined,
-      },
+      // Active accounts from wallet scan
+      ...state.activeAccounts
+        .filter(a => a.active && isSigningAccount(a))
+        .flatMap(a => {
+          const entries = [];
+          const pathLabel = a.path || `m/44'/${a.coinType}'/${a.account}'/0/${a.index}`;
+          try {
+            const { publicKey } = deriveAddressForPath(a.coinType, a.account, a.index);
+            const curve = a.coinType === 501 ? 'Ed25519' : 'secp256k1';
+            entries.push({
+              PUBLIC_KEY: toBase64(publicKey),
+              LABEL: `${curve} ${pathLabel}`,
+            });
+          } catch {}
+          if (a.address) {
+            entries.push({
+              KEY_ADDRESS: a.address,
+              LABEL: pathLabel,
+            });
+          }
+          return entries;
+        }),
     ];
+  } else if (info.xpubOnly && state.hdRoot?.toXpub) {
+    person.KEY = [{ XPUB: state.hdRoot.toXpub(), LABEL: '' }];
   }
 
   const note = info.includeKeys
-    ? 'Generated by HD Wallet UI'
+    ? 'Generated by Space Data Network'
     : undefined;
 
   let vcard = createV3(person, note);
 
+  // Add NICKNAME field (not supported by createV3)
+  if (info.nickname) {
+    vcard = vcard.replace('END:VCARD', `NICKNAME:${info.nickname}\nEND:VCARD`);
+  }
+
+
   // Convert PHOTO from data URI format to iOS-compatible inline base64 format
   vcard = vcard.replace(
     /PHOTO;VALUE=URI:data:image\/(\w+);base64,([^\n]+)\n/,
@@ -1709,127 +3176,126 @@ function generateVCard(info, { skipPhoto = false } = {}) {
 }
 
 // =============================================================================
-// vCard Keys Display
+// vCard Digital Signature (Ed25519)
 // =============================================================================
 
-function populateVCardKeysDisplay() {
-  const keysDisplay = $('vcard-keys-display');
-  if (!keysDisplay) return;
+function getSignableBody(vcardText) {
+  const lines = vcardText.split('\n');
+  const sigItems = new Set();
+  for (const line of lines) {
+    const m = line.match(/^item(\d+)\.X-ABLabel:Digital Signature/);
+    if (m) sigItems.add(m[1]);
+  }
+  return lines.filter(line => {
+    if (line.trim() === 'END:VCARD') return false;
+    for (const n of sigItems) {
+      if (line.startsWith(`item${n}.`)) return false;
+    }
+    return true;
+  }).join('\n') + '\n';
+}
+
+function signVCard(vcardText) {
+  if (!state.wallet?.ed25519?.privateKey) return vcardText;
+
+  const body = getSignableBody(vcardText);
+  const messageBytes = new TextEncoder().encode(body);
+  const signature = ed25519.sign(messageBytes, state.wallet.ed25519.privateKey);
+  const sigB64 = toBase64(signature);
+
+  // Encode signature + derivation path (coinType=501, account=0, index=0)
+  const sigValue = `${sigB64}:501:0:0`;
+
+  // Find highest itemN and key index
+  let maxItem = 0;
+  let maxKeyIdx = 0;
+  const itemRe = /item(\d+)\./g;
+  const keyIdxRe = /#(\d+)/g;
+  let match;
+  while ((match = itemRe.exec(vcardText)) !== null) {
+    maxItem = Math.max(maxItem, parseInt(match[1], 10));
+  }
+  while ((match = keyIdxRe.exec(vcardText)) !== null) {
+    maxKeyIdx = Math.max(maxKeyIdx, parseInt(match[1], 10));
+  }
+
+  const sigLines =
+    `item${maxItem + 1}.X-ABLabel:Digital Signature #${maxKeyIdx + 1}\n` +
+    `item${maxItem + 1}.X-ABRELATEDNAMES:${sigValue}\n`;
 
-  const keys = [];
+  return body + sigLines + 'END:VCARD';
+}
 
-  // Bitcoin signing key
-  if (state.addresses.btc) {
-    keys.push({
-      label: 'Bitcoin Signing',
-      curve: 'secp256k1',
-      address: state.addresses.btc,
-      pubkey: state.wallet.secp256k1 ? toHex(state.wallet.secp256k1.publicKey) : '—',
-      path: buildSigningPath(0, 0, 0), // m/44'/0'/0'/0'/0'
-      role: 'signing',
-      explorer: `https://blockstream.info/address/${state.addresses.btc}`,
-    });
+function verifyVCardSignature(vcardText) {
+  // Parse all itemN label/value pairs
+  const lines = vcardText.split('\n');
+  const items = {};
+  for (const line of lines) {
+    const labelMatch = line.match(/^item(\d+)\.X-ABLabel:(.+)/);
+    if (labelMatch) {
+      items[labelMatch[1]] = items[labelMatch[1]] || {};
+      items[labelMatch[1]].label = labelMatch[2].trim();
+    }
+    const valueMatch = line.match(/^item(\d+)\.X-ABRELATEDNAMES:(.+)/);
+    if (valueMatch) {
+      items[valueMatch[1]] = items[valueMatch[1]] || {};
+      items[valueMatch[1]].value = valueMatch[2].trim();
+    }
   }
 
-  // Ethereum signing key
-  if (state.addresses.eth) {
-    keys.push({
-      label: 'Ethereum Signing',
-      curve: 'secp256k1',
-      address: state.addresses.eth,
-      pubkey: state.wallet.secp256k1 ? toHex(state.wallet.secp256k1.publicKey) : '—',
-      path: buildSigningPath(60, 0, 0), // m/44'/60'/0'/0'/0'
-      role: 'signing',
-      explorer: `https://etherscan.io/address/${state.addresses.eth}`,
-    });
+  // Find Digital Signature entry
+  let sigValue = null;
+  for (const item of Object.values(items)) {
+    if (item.label?.startsWith('Digital Signature') && item.value) {
+      sigValue = item.value;
+    }
   }
 
-  // Solana signing key
-  if (state.addresses.sol) {
-    keys.push({
-      label: 'Solana Signing',
-      curve: 'Ed25519',
-      address: state.addresses.sol,
-      pubkey: state.wallet.ed25519 ? toHex(state.wallet.ed25519.publicKey) : '—',
-      path: buildSigningPath(501, 0, 0), // m/44'/501'/0'/0'
-      role: 'signing',
-      explorer: `https://explorer.solana.com/address/${state.addresses.sol}`,
-    });
+  if (!sigValue) {
+    return { verified: false, path: null, publicKey: null, error: 'unsigned' };
   }
 
-  // P-256 encryption key
-  if (state.wallet.p256) {
-    keys.push({
-      label: 'Encryption Key',
-      curve: 'P-256 (NIST)',
-      address: '—',
-      pubkey: toHex(state.wallet.p256.publicKey),
-      path: buildEncryptionPath(0, 0, 0), // m/44'/0'/0'/1'/0'
-      role: 'encryption',
-      explorer: null,
-    });
+  // Parse signature value: base64sig:coinType:account:index
+  const parts = sigValue.split(':');
+  if (parts.length < 4) {
+    return { verified: false, path: null, publicKey: null, error: 'Malformed signature' };
+  }
+  const sigB64 = parts[0];
+  const coinType = parts[1];
+  const account = parts[2];
+  const index = parts[3];
+  const path = `m/44'/${coinType}'/${account}'/0/${index}`;
+
+  // Find Ed25519 public key — look for "Public Key" entries with 32-byte (44-char base64) values
+  let ed25519PubB64 = null;
+  for (const item of Object.values(items)) {
+    if (item.label?.startsWith('Public Key') && item.value) {
+      try {
+        const decoded = Uint8Array.from(atob(item.value), c => c.charCodeAt(0));
+        if (decoded.length === 32) {
+          ed25519PubB64 = item.value;
+          break;
+        }
+      } catch { /* not base64 */ }
+    }
   }
 
-  // Clear and populate
-  keysDisplay.innerHTML = '';
+  if (!ed25519PubB64) {
+    return { verified: false, path, publicKey: null, error: 'No Ed25519 public key found' };
+  }
 
-  keys.forEach(key => {
-    const keyCard = document.createElement('div');
-    keyCard.className = 'key-display-card';
-    keyCard.innerHTML = `
-      <div class="key-display-header">
-        <span class="key-display-label">${key.label}</span>
-        <span class="key-display-badge ${key.role}">${key.role}</span>
-      </div>
-      <div class="key-display-row">
-        <span class="key-display-field">Curve</span>
-        <code class="key-display-value">${key.curve}</code>
-      </div>
-      <div class="key-display-row">
-        <span class="key-display-field">Public Key</span>
-        <code class="key-display-value truncate" title="${key.pubkey}">${truncateAddress(key.pubkey, 16)}</code>
-        <button class="copy-btn-small" data-copy-text="${key.pubkey}" title="Copy">
-          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-            <rect x="9" y="9" width="13" height="13" rx="2" ry="2"/>
-            <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
-          </svg>
-        </button>
-      </div>
-      ${key.address !== '—' ? `
-      <div class="key-display-row">
-        <span class="key-display-field">Address</span>
-        <code class="key-display-value truncate" title="${key.address}">${truncateAddress(key.address, 16)}</code>
-        ${key.explorer ? `<a href="${key.explorer}" target="_blank" rel="noopener" class="explorer-link-small" title="View on Explorer">
-          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-            <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/>
-            <polyline points="15 3 21 3 21 9"/>
-            <line x1="10" y1="14" x2="21" y2="3"/>
-          </svg>
-        </a>` : ''}
-      </div>
-      ` : ''}
-      <div class="key-display-row">
-        <span class="key-display-field">Derivation Path</span>
-        <code class="key-display-value">${key.path}</code>
-      </div>
-    `;
-    keysDisplay.appendChild(keyCard);
-  });
+  // Reconstruct signable body and verify
+  const body = getSignableBody(vcardText);
+  const messageBytes = new TextEncoder().encode(body);
+  const sigBytes = Uint8Array.from(atob(sigB64), c => c.charCodeAt(0));
+  const pubKeyBytes = Uint8Array.from(atob(ed25519PubB64), c => c.charCodeAt(0));
 
-  // Add copy button event listeners
-  keysDisplay.querySelectorAll('.copy-btn-small').forEach(btn => {
-    btn.addEventListener('click', async () => {
-      const text = btn.getAttribute('data-copy-text');
-      try {
-        await navigator.clipboard.writeText(text);
-        const originalHTML = btn.innerHTML;
-        btn.innerHTML = '✓';
-        setTimeout(() => { btn.innerHTML = originalHTML; }, 1000);
-      } catch (err) {
-        console.error('Copy failed:', err);
-      }
-    });
-  });
+  try {
+    const valid = ed25519.verify(sigBytes, messageBytes, pubKeyBytes);
+    return { verified: valid, path, publicKey: ed25519PubB64, error: valid ? null : 'Signature invalid' };
+  } catch (e) {
+    return { verified: false, path, publicKey: ed25519PubB64, error: e.message };
+  }
 }
 
 function parseAndDisplayVCF(vcfText) {
@@ -1913,6 +3379,23 @@ function parseAndDisplayVCF(vcfText) {
     html += '</div>';
   }
 
+  // Verify digital signature
+  const sigStatus = $('vcf-import-sig-status');
+  if (sigStatus) {
+    const result = verifyVCardSignature(vcfText);
+    if (result.error === 'unsigned') {
+      sigStatus.className = 'vcard-sig-badge sig-unsigned';
+      sigStatus.innerHTML = 'No signature';
+    } else if (result.verified) {
+      sigStatus.className = 'vcard-sig-badge sig-verified';
+      sigStatus.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/></svg> Verified (${result.path})`;
+    } else {
+      sigStatus.className = 'vcard-sig-badge sig-invalid';
+      sigStatus.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/></svg> Invalid signature`;
+    }
+    sigStatus.style.display = 'flex';
+  }
+
   fieldsEl.innerHTML = html;
   resultEl.style.display = 'block';
 }
@@ -2404,7 +3887,6 @@ function setupMainAppHandlers() {
   $('nav-logout')?.addEventListener('click', logout);
   $('nav-keys')?.addEventListener('click', async () => {
     $('keys-modal')?.classList.add('active');
-    deriveAndDisplayAddress();
     if (state.loggedIn) {
       const names = await resolveNames();
       updateAccountTitle(names);
@@ -2431,11 +3913,55 @@ function setupMainAppHandlers() {
     });
   });
 
+  // Messaging sub-tab switching
+  $qa('.messaging-sub-tab').forEach(tab => {
+    tab.addEventListener('click', () => {
+      $qa('.messaging-sub-tab').forEach(t => t.classList.remove('active'));
+      $qa('.messaging-sub-content').forEach(c => c.classList.remove('active'));
+      tab.classList.add('active');
+      const target = $(tab.dataset.messagingSub);
+      if (target) target.classList.add('active');
+    });
+  });
+
+  // Identity card summary — updates the read-only card display from form fields
+  function updateIdentityCardSummary() {
+    const prefix = $('vcard-prefix')?.value || '';
+    const first = $('vcard-firstname')?.value || '';
+    const middle = $('vcard-middlename')?.value || '';
+    const last = $('vcard-lastname')?.value || '';
+    const suffix = $('vcard-suffix')?.value || '';
+    const nick = $('vcard-nickname')?.value || '';
+    const parts = [prefix, first, middle, last, suffix].filter(Boolean);
+    const nameEl = $('identity-card-name');
+    if (nameEl) {
+      const namePart = parts.length > 0 ? parts.join(' ') : '--';
+      if (nick) {
+        nameEl.innerHTML = `${namePart} <span class="nickname">(${nick})</span>`;
+      } else {
+        nameEl.textContent = namePart;
+      }
+    }
+
+    const titleEl = $('identity-card-title');
+    if (titleEl) titleEl.textContent = $('vcard-title')?.value || '';
+
+    const orgEl = $('identity-card-org');
+    if (orgEl) orgEl.textContent = $('vcard-org')?.value || '';
+
+    const emailEl = $('identity-card-email');
+    if (emailEl) emailEl.textContent = $('vcard-email')?.value || '';
+
+    const phoneEl = $('identity-card-phone');
+    if (phoneEl) phoneEl.textContent = $('vcard-phone')?.value || '';
+  }
+
+
   // vCard identity auto-save
   const VCARD_STORAGE_KEY = 'hd-wallet-vcard-identity';
   const vcardFieldIds = [
     'vcard-prefix', 'vcard-firstname', 'vcard-middlename', 'vcard-lastname',
-    'vcard-suffix', 'vcard-email', 'vcard-phone', 'vcard-org', 'vcard-title',
+    'vcard-suffix', 'vcard-nickname', 'vcard-email', 'vcard-phone', 'vcard-org', 'vcard-title',
     'vcard-street', 'vcard-city', 'vcard-region', 'vcard-postal', 'vcard-country'
   ];
 
@@ -2466,16 +3992,95 @@ function setupMainAppHandlers() {
   }
 
   restoreVcardIdentity();
+  updateIdentityCardSummary();
 
-  let vcardSaveTimer = null;
-  function debouncedVcardSave() {
-    clearTimeout(vcardSaveTimer);
-    vcardSaveTimer = setTimeout(saveVcardIdentity, 500);
+  // Snapshot of field values before editing (for Back/cancel)
+  let _vcardEditSnapshot = {};
+
+  function snapshotVcardFields() {
+    _vcardEditSnapshot = {};
+    for (const id of vcardFieldIds) {
+      const el = $(id);
+      if (el) _vcardEditSnapshot[id] = el.value;
+    }
+  }
+
+  function restoreVcardSnapshot() {
+    for (const id of vcardFieldIds) {
+      const el = $(id);
+      if (el && _vcardEditSnapshot[id] !== undefined) el.value = _vcardEditSnapshot[id];
+    }
   }
 
-  for (const id of vcardFieldIds) {
-    $(id)?.addEventListener('input', debouncedVcardSave);
+  // Edit button — switch to edit view
+  $('identity-edit-btn')?.addEventListener('click', () => {
+    setPhotoActionsVisible(false);
+    stopCamera();
+    snapshotVcardFields();
+    $('vcard-form-view').style.display = 'none';
+    $('vcard-edit-view').style.display = 'flex';
+  });
+
+  // Save button — persist and return to card view
+  $('identity-save-btn')?.addEventListener('click', () => {
+    saveVcardIdentity();
+    updateIdentityCardSummary();
+    setPhotoActionsVisible(false);
+    $('vcard-edit-view').style.display = 'none';
+    $('vcard-form-view').style.display = '';
+  });
+
+  // Back button — discard changes and return to card view
+  $('identity-back-btn')?.addEventListener('click', () => {
+    restoreVcardSnapshot();
+    setPhotoActionsVisible(false);
+    stopCamera();
+    $('vcard-edit-view').style.display = 'none';
+    $('vcard-form-view').style.display = '';
+  });
+
+  const photoActions = $('vcard-photo-actions');
+  const photoEditBtn = $('vcard-photo-edit-btn');
+  function setPhotoActionsVisible(visible) {
+    if (photoActions) photoActions.classList.toggle('visible', visible);
+    if (photoEditBtn) {
+      photoEditBtn.classList.toggle('is-open', visible);
+      photoEditBtn.title = visible ? 'Close Photo Menu' : 'Edit Photo';
+    }
+  }
+  function arePhotoActionsVisible() {
+    return !!photoActions?.classList.contains('visible');
   }
+  setPhotoActionsVisible(false);
+
+  function encodeVcardPhoto(source, sourceWidth, sourceHeight) {
+    if (!source || !sourceWidth || !sourceHeight) return null;
+    const maxDimension = 1024;
+    const quality = 0.9;
+    const scale = Math.min(1, maxDimension / Math.max(sourceWidth, sourceHeight));
+    const outputWidth = Math.max(1, Math.round(sourceWidth * scale));
+    const outputHeight = Math.max(1, Math.round(sourceHeight * scale));
+    const canvas = document.createElement('canvas');
+    canvas.width = outputWidth;
+    canvas.height = outputHeight;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) return null;
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = 'high';
+    ctx.drawImage(source, 0, 0, sourceWidth, sourceHeight, 0, 0, outputWidth, outputHeight);
+    return canvas.toDataURL('image/jpeg', quality);
+  }
+
+  photoEditBtn?.addEventListener('click', (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (arePhotoActionsVisible()) {
+      setPhotoActionsVisible(false);
+      stopCamera();
+      return;
+    }
+    setPhotoActionsVisible(true);
+  });
 
   // Photo upload handler
   $('vcard-photo-input')?.addEventListener('change', (e) => {
@@ -2485,19 +4090,12 @@ function setupMainAppHandlers() {
     reader.onload = (ev) => {
       const img = new Image();
       img.onload = () => {
-        const canvas = document.createElement('canvas');
-        const size = 128;
-        canvas.width = size;
-        canvas.height = size;
-        const ctx = canvas.getContext('2d');
-        const min = Math.min(img.width, img.height);
-        const sx = (img.width - min) / 2;
-        const sy = (img.height - min) / 2;
-        ctx.drawImage(img, sx, sy, min, min, 0, 0, size, size);
-        const dataUrl = canvas.toDataURL('image/jpeg', 0.7);
+        const dataUrl = encodeVcardPhoto(img, img.width, img.height);
+        if (!dataUrl) return;
         state.vcardPhoto = dataUrl;
         stopCamera();
         showPhotoPreview(dataUrl);
+        setPhotoActionsVisible(false);
         saveVcardIdentity();
       };
       img.src = ev.target.result;
@@ -2526,6 +4124,7 @@ function setupMainAppHandlers() {
       const cameraBtn = $('vcard-camera-btn');
       if (cameraBtn) cameraBtn.style.display = '';
     }
+    setPhotoActionsVisible(false);
     const modal = $('photo-remove-confirm-modal');
     if (modal) modal.classList.remove('active');
   });
@@ -2543,6 +4142,14 @@ function setupMainAppHandlers() {
     if (placeholder) placeholder.style.display = '';
     const video = $('vcard-camera-video');
     if (video) video.style.display = 'none';
+    const removeBtn = $('vcard-photo-remove');
+    if (removeBtn) removeBtn.style.display = 'none';
+    const uploadLabel = document.querySelector('label[for="vcard-photo-input"]');
+    if (uploadLabel) uploadLabel.style.display = '';
+    const cameraBtn = $('vcard-camera-btn');
+    if (cameraBtn && navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
+      cameraBtn.style.display = '';
+    }
   }
 
   function showPhotoPreview(dataUrl) {
@@ -2559,23 +4166,28 @@ function setupMainAppHandlers() {
     preview.appendChild(img);
     const removeBtn = $('vcard-photo-remove');
     if (removeBtn) removeBtn.style.display = '';
-    // Hide upload/camera buttons when photo is present
     const uploadLabel = document.querySelector('label[for="vcard-photo-input"]');
-    if (uploadLabel) uploadLabel.style.display = 'none';
+    if (uploadLabel) uploadLabel.style.display = '';
     const cameraBtn = $('vcard-camera-btn');
-    if (cameraBtn) cameraBtn.style.display = 'none';
+    if (cameraBtn && navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
+      cameraBtn.style.display = '';
+    }
   }
 
   // Camera support
   let cameraStream = null;
   if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
     const cameraBtn = $('vcard-camera-btn');
-    if (cameraBtn && !state.vcardPhoto) cameraBtn.style.display = '';
+    if (cameraBtn) cameraBtn.style.display = '';
 
     cameraBtn?.addEventListener('click', async () => {
       try {
         cameraStream = await navigator.mediaDevices.getUserMedia({
-          video: { facingMode: 'user', width: { ideal: 512 }, height: { ideal: 512 } }
+          video: {
+            facingMode: 'user',
+            width: { ideal: 1280, max: 1920 },
+            height: { ideal: 720, max: 1080 },
+          }
         });
         const video = $('vcard-camera-video');
         if (video) {
@@ -2590,6 +4202,10 @@ function setupMainAppHandlers() {
           preview.querySelectorAll('img').forEach(el => el.style.display = 'none');
         }
         cameraBtn.style.display = 'none';
+        const uploadLabel = document.querySelector('label[for="vcard-photo-input"]');
+        if (uploadLabel) uploadLabel.style.display = 'none';
+        const removeBtn = $('vcard-photo-remove');
+        if (removeBtn) removeBtn.style.display = 'none';
         const captureBtn = $('vcard-camera-capture');
         const cancelBtn = $('vcard-camera-cancel');
         if (captureBtn) captureBtn.style.display = '';
@@ -2603,21 +4219,14 @@ function setupMainAppHandlers() {
     $('vcard-camera-capture')?.addEventListener('click', () => {
       const video = $('vcard-camera-video');
       if (!video) return;
-      const canvas = document.createElement('canvas');
-      const size = 128;
-      canvas.width = size;
-      canvas.height = size;
-      const ctx = canvas.getContext('2d');
       const vw = video.videoWidth;
       const vh = video.videoHeight;
-      const min = Math.min(vw, vh);
-      const sx = (vw - min) / 2;
-      const sy = (vh - min) / 2;
-      ctx.drawImage(video, sx, sy, min, min, 0, 0, size, size);
-      const dataUrl = canvas.toDataURL('image/jpeg', 0.7);
+      const dataUrl = encodeVcardPhoto(video, vw, vh);
+      if (!dataUrl) return;
       state.vcardPhoto = dataUrl;
       stopCamera();
       showPhotoPreview(dataUrl);
+      setPhotoActionsVisible(false);
       saveVcardIdentity();
     });
 
@@ -2642,9 +4251,13 @@ function setupMainAppHandlers() {
       video.style.display = 'none';
     }
     const cameraBtn = $('vcard-camera-btn');
+    const uploadLabel = document.querySelector('label[for="vcard-photo-input"]');
+    const removeBtn = $('vcard-photo-remove');
     const captureBtn = $('vcard-camera-capture');
     const cancelBtn = $('vcard-camera-cancel');
-    if (cameraBtn) cameraBtn.style.display = state.vcardPhoto ? 'none' : '';
+    if (uploadLabel) uploadLabel.style.display = '';
+    if (removeBtn) removeBtn.style.display = state.vcardPhoto ? '' : 'none';
+    if (cameraBtn && navigator.mediaDevices && navigator.mediaDevices.getUserMedia) cameraBtn.style.display = '';
     if (captureBtn) captureBtn.style.display = 'none';
     if (cancelBtn) cancelBtn.style.display = 'none';
   }
@@ -2694,28 +4307,13 @@ function setupMainAppHandlers() {
     });
   });
 
-  // Export wallet dropdown
-  const exportBtn = $('export-wallet-btn');
-  const exportMenu = $('export-menu');
-  if (exportBtn && exportMenu) {
-    exportBtn.addEventListener('click', () => {
-      exportMenu.classList.toggle('active');
-    });
-
-    _root.addEventListener('click', (e) => {
-      if (!exportBtn.contains(e.target) && !exportMenu.contains(e.target)) {
-        exportMenu.classList.remove('active');
-      }
-    });
-
-    $qa('.export-option').forEach(option => {
-      option.addEventListener('click', async () => {
-        const format = option.dataset.format;
-        await exportWallet(format);
-        exportMenu.classList.remove('active');
-      });
+  // Export wallet options
+  $qa('.export-option').forEach(option => {
+    option.addEventListener('click', async () => {
+      const format = option.dataset.format;
+      await exportWallet(format);
     });
-  }
+  });
 
   // Mobile menu toggle
   const mobileMenuBtn = $('nav-menu-btn');
@@ -2769,21 +4367,145 @@ function setupMainAppHandlers() {
     });
   });
 
-  // HD wallet controls
-  $('hd-coin')?.addEventListener('change', () => {
-    updatePathDisplay();
-    deriveAndDisplayAddress();
-    updateEncryptionTab();
+  // Wallet tab controls
+  $('wallet-active-select')?.addEventListener('change', (e) => {
+    const walletId = Number.parseInt(e.target.value, 10);
+    if (Number.isNaN(walletId)) return;
+    state.activeWalletId = walletId;
+    closeWalletActionMenus();
+    renderWalletSelector();
+    renderAccountsList();
+    updateCustomPathDefault();
+  });
+  $('wallet-manage-btn')?.addEventListener('click', () => {
+    closeWalletActionMenus();
+    showWalletsView();
+  });
+  $('wallet-scan-btn')?.addEventListener('click', () => {
+    scanActiveAccounts();
+  });
+  const sendAction = $('wallet-send-action');
+  const receiveAction = $('wallet-receive-action');
+  $('wallet-send-btn')?.addEventListener('click', (e) => {
+    e.stopPropagation();
+    updateWalletActionMenus();
+    const sendMenu = $('wallet-send-menu');
+    const receiveMenu = $('wallet-receive-menu');
+    if (!sendMenu || !receiveMenu) return;
+    const nextVisible = !sendMenu.classList.contains('visible');
+    receiveMenu.classList.remove('visible');
+    sendMenu.classList.toggle('visible', nextVisible);
+  });
+  $('wallet-receive-btn-main')?.addEventListener('click', (e) => {
+    e.stopPropagation();
+    updateWalletActionMenus();
+    const sendMenu = $('wallet-send-menu');
+    const receiveMenu = $('wallet-receive-menu');
+    if (!sendMenu || !receiveMenu) return;
+    const nextVisible = !receiveMenu.classList.contains('visible');
+    sendMenu.classList.remove('visible');
+    receiveMenu.classList.toggle('visible', nextVisible);
+  });
+  $qa('#wallet-send-menu .ph-action-menu-item').forEach((btn) => {
+    btn.addEventListener('click', (e) => {
+      e.stopPropagation();
+      const chain = btn.dataset.chain;
+      const acct = getWalletAccountForChain(chain);
+      closeWalletActionMenus();
+      if (!acct) return;
+      showSendView(state.activeAccounts.indexOf(acct));
+    });
+  });
+  $qa('#wallet-receive-menu .ph-action-menu-item').forEach((btn) => {
+    btn.addEventListener('click', (e) => {
+      e.stopPropagation();
+      const chain = btn.dataset.chain;
+      const acct = getWalletAccountForChain(chain);
+      closeWalletActionMenus();
+      if (!acct) return;
+      showReceiveModal(acct);
+    });
+  });
+  _root.addEventListener('click', (e) => {
+    if (sendAction?.contains(e.target) || receiveAction?.contains(e.target)) return;
+    closeWalletActionMenus();
   });
-  $('hd-account')?.addEventListener('input', () => {
-    updatePathDisplay();
-    deriveAndDisplayAddress();
-    updateEncryptionTab();
+  $('wallet-export-btn-main')?.addEventListener('click', () => {
+    closeWalletActionMenus();
+    showExportView();
   });
-  $('hd-index')?.addEventListener('input', () => {
-    updatePathDisplay();
-    deriveAndDisplayAddress();
-    updateEncryptionTab();
+  $('wallet-advanced-btn-main')?.addEventListener('click', () => {
+    closeWalletActionMenus();
+    showAdvancedView();
+  });
+  $('wallet-wallets-back')?.addEventListener('click', () => {
+    showWalletMainView();
+  });
+  $('wallet-manage-tab-active')?.addEventListener('click', () => {
+    setWalletManageTab('active');
+  });
+  $('wallet-manage-tab-inactive')?.addEventListener('click', () => {
+    setWalletManageTab('inactive');
+  });
+  $('wallet-export-back')?.addEventListener('click', () => {
+    showWalletMainView();
+  });
+  $('wallet-advanced-back')?.addEventListener('click', () => {
+    showWalletMainView();
+  });
+  // New Wallet in wallets view
+  $('wallet-new-btn')?.addEventListener('click', () => {
+    createNewWallet();
+  });
+  // Custom derivation path
+  $('custom-path-add')?.addEventListener('click', () => {
+    addCustomPathAccount();
+  });
+  $('custom-path-chain')?.addEventListener('change', () => {
+    updateCustomPathDefault();
+  });
+  $('custom-path-input')?.addEventListener('input', (e) => {
+    e.target.dataset.autogenerated = 'false';
+  });
+  // Send flow
+  $('wallet-send-back')?.addEventListener('click', () => {
+    hideSendView();
+  });
+  $('send-from-account')?.addEventListener('change', () => {
+    updateSendFromSelection();
+  });
+  $('send-to-address')?.addEventListener('input', () => {
+    validateSendForm();
+  });
+  $('send-amount')?.addEventListener('input', () => {
+    validateSendForm();
+    updateSendFiatEstimate();
+  });
+  $('send-max-btn')?.addEventListener('click', () => {
+    const select = $('send-from-account');
+    const amountInput = $('send-amount');
+    if (!select || !amountInput) return;
+    const idx = parseInt(select.value);
+    const acct = state.activeAccounts[idx];
+    if (!acct) return;
+    const bal = parseFloat(acct.balance);
+    if (!isNaN(bal) && bal > 0) {
+      amountInput.value = bal;
+      validateSendForm();
+      updateSendFiatEstimate();
+    }
+  });
+  $('send-review-btn')?.addEventListener('click', () => {
+    showSendReview();
+  });
+  $('send-confirm-btn')?.addEventListener('click', () => {
+    executeSend();
+  });
+  $('send-edit-btn')?.addEventListener('click', () => {
+    const compose = $('send-compose-step');
+    const review = $('send-review-step');
+    if (compose) compose.style.display = 'block';
+    if (review) review.style.display = 'none';
   });
 
   // PKI clear keys
@@ -2845,7 +4567,9 @@ function setupMainAppHandlers() {
       middleName: $('vcard-middlename')?.value || '',
       lastName: $('vcard-lastname')?.value || '',
       suffix: $('vcard-suffix')?.value || '',
+      nickname: $('vcard-nickname')?.value || '',
       email: $('vcard-email')?.value || '',
+      phone: $('vcard-phone')?.value || '',
       org: $('vcard-org')?.value || '',
       title: $('vcard-title')?.value || '',
       includeKeys: true,
@@ -2856,10 +4580,9 @@ function setupMainAppHandlers() {
       return;
     }
 
-    const vcard = generateVCard(info);
-    const vcardForQR = generateVCard(info, { skipPhoto: true });
-    const vcardPreview = $('vcard-preview');
-    if (vcardPreview) vcardPreview.textContent = vcard;
+    const vcard = signVCard(generateVCard(info));
+    const vcardForQR = signVCard(generateVCard(info, { skipPhoto: true }));
+    state._exportedVCard = vcard;
 
     try {
       const qrCanvas = $('qr-code');
@@ -2874,11 +4597,49 @@ function setupMainAppHandlers() {
       const resultView = $('vcard-result-view');
       if (formView) formView.style.display = 'none';
       if (resultView) resultView.style.display = '';
+
+      // Show/hide signature badge
+      const sigBadge = $('vcard-sig-badge');
+      if (sigBadge) {
+        sigBadge.style.display = state.wallet?.ed25519?.privateKey ? 'flex' : 'none';
+      }
+
+      // Populate raw view (strip PHOTO base64 data)
+      const rawView = $('vcard-raw-view');
+      if (rawView) {
+        const rawText = vcard.replace(/PHOTO;ENCODING=b;TYPE=\w+:[\s\S]*?(?=\n[A-Z])/m, 'PHOTO:[image data omitted]');
+        rawView.textContent = rawText;
+      }
+
+      // Reset toggle to QR
+      $('vcard-toggle-qr')?.classList.add('active');
+      $('vcard-toggle-raw')?.classList.remove('active');
+      document.querySelector('.qr-container')?.style.setProperty('display', '');
+      if (rawView) rawView.style.display = 'none';
     } catch (err) {
       alert('Error generating QR code: ' + err.message);
     }
   });
 
+  // Toggle QR / Raw
+  $('vcard-toggle-qr')?.addEventListener('click', () => {
+    $('vcard-toggle-qr')?.classList.add('active');
+    $('vcard-toggle-raw')?.classList.remove('active');
+    const qr = document.querySelector('#vcard-result-view .qr-container');
+    const raw = $('vcard-raw-view');
+    if (qr) qr.style.display = '';
+    if (raw) raw.style.display = 'none';
+  });
+
+  $('vcard-toggle-raw')?.addEventListener('click', () => {
+    $('vcard-toggle-raw')?.classList.add('active');
+    $('vcard-toggle-qr')?.classList.remove('active');
+    const qr = document.querySelector('#vcard-result-view .qr-container');
+    const raw = $('vcard-raw-view');
+    if (qr) qr.style.display = 'none';
+    if (raw) raw.style.display = '';
+  });
+
   // Back to editor from result view
   $('vcard-back-btn')?.addEventListener('click', () => {
     const resultView = $('vcard-result-view');
@@ -2889,7 +4650,7 @@ function setupMainAppHandlers() {
 
   // Download vCard
   $('download-vcard')?.addEventListener('click', () => {
-    const vcard = $('vcard-preview')?.textContent || '';
+    const vcard = state._exportedVCard || '';
     const blob = new Blob([vcard], { type: 'text/vcard' });
     const url = URL.createObjectURL(blob);
     const a = document.createElement('a');
@@ -2901,7 +4662,7 @@ function setupMainAppHandlers() {
 
   // Copy vCard
   $('copy-vcard')?.addEventListener('click', async () => {
-    const vcard = $('vcard-preview')?.textContent || '';
+    const vcard = state._exportedVCard || '';
     try {
       await navigator.clipboard.writeText(vcard);
       const btn = $('copy-vcard');
@@ -2936,13 +4697,19 @@ function setupMainAppHandlers() {
 
 function setupTrustHandlers() {
   let trustScanInterval = null;
-  const TRUST_SCAN_INTERVAL_MS = 60000; // 60 seconds
+  let trustScanRunning = false;
+  let trustNextAllowedAt = 0;
+  const TRUST_SCAN_INTERVAL_MS = 3 * 60 * 1000; // 3 minutes
+  const TRUST_SCAN_FAIL_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes on failure
   const TRUST_RULES_KEY = 'trust-rules';
   const TRUST_IMPORTED_KEY = 'trust-imported-txs';
 
   // Auto-scan trust transactions
   async function runTrustScan() {
     if (!state.loggedIn || !state.addresses) return;
+    if (trustScanRunning) return;
+    if (Date.now() < trustNextAllowedAt) return;
+    trustScanRunning = true;
 
     const statusEl = $('trust-scan-status');
     const labelEl = $('trust-scan-label');
@@ -2999,14 +4766,22 @@ function setupTrustHandlers() {
       if (countEl) countEl.textContent = `${relationships.length} relationships`;
 
       console.log(`Trust scan: ${dedupedTxs.length} txs, ${relationships.length} relationships`);
+      trustNextAllowedAt = 0;
     } catch (err) {
       console.error('Trust scan failed:', err);
-      if (labelEl) labelEl.textContent = 'Scan failed';
+      trustNextAllowedAt = Date.now() + TRUST_SCAN_FAIL_COOLDOWN_MS;
+      if (labelEl) labelEl.textContent = 'Scan delayed (endpoint limited)';
+    } finally {
+      trustScanRunning = false;
     }
   }
 
   // Start auto-scanning
   function startTrustScanning() {
+    if (trustScanInterval) {
+      clearInterval(trustScanInterval);
+      trustScanInterval = null;
+    }
     runTrustScan();
     trustScanInterval = setInterval(runTrustScan, TRUST_SCAN_INTERVAL_MS);
   }
@@ -3091,7 +4866,7 @@ function setupTrustHandlers() {
       return;
     }
     const { exportTrustData } = await import('./trust-ui.js');
-    const xpub = state.hdRoot ? state.hdRoot.publicExtendedKey() : '';
+    const xpub = state.hdRoot ? state.hdRoot.toXpub() : '';
     exportTrustData(state.trustTransactions, xpub);
   });
 
@@ -3158,7 +4933,7 @@ function setupTrustHandlers() {
   }
 
   // Update encryption tab when it becomes active or HD controls change
-  $qa('.modal-tab[data-modal-tab="encrypt-tab-content"]').forEach(tab => {
+  $qa('.modal-tab[data-modal-tab="messaging-tab-content"]').forEach(tab => {
     tab.addEventListener('click', () => {
       if (state.hdRoot) updateEncryptionTab();
     });