hd-wallet-ui 1.2.1 → 1.2.3

package/src/app.js

@@ -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 barEl = $('wallet-scan-bar');
+  const scanBtn = $('wallet-scan-btn');
+  if (statusEl) statusEl.style.display = 'block';
+  if (barEl) barEl.style.width = '0%';
+  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 (let ti = 0; ti < targets.length; ti++) {
+      const target = targets[ti];
+      if (barEl) barEl.style.width = Math.round(((ti + 1) / targets.length) * 100) + '%';
+
+      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
@@ -910,7 +2485,6 @@ function login(keys) {
 
   // Open Account modal so user can see the wallet they just loaded
   $('keys-modal')?.classList.add('active');
-  deriveAndDisplayAddress();
 
   // Resolve names and update title
   clearNameCache();
@@ -1063,7 +2637,7 @@ function populateAccountAddressDropdown() {
   if (!addrEl) return;
 
   const xpubStr = state.hdRoot ? state.hdRoot.toXpub() : '';
-  addrEl.textContent = xpubStr;
+  addrEl.textContent = `${xpubStr.slice(0,10)}...${xpubStr.slice(-10)}`;
   addrEl.title = xpubStr;
 
   const copyBtn = $('account-address-copy');
@@ -1177,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';
 }
@@ -1189,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
@@ -1204,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;
 }
 
@@ -1414,140 +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);
-  }
-
+  // Wallet tab bond total is now updated by scanActiveAccounts/updateWalletBondTotal
+  updateWalletBondTotal();
 }
 
 // =============================================================================
@@ -1590,23 +3110,38 @@ function generateVCard(info, { skipPhoto = false } = {}) {
 
   if (info.includeKeys && state.wallet?.x25519) {
     person.KEY = [
+      // Always include xPub
       ...(state.hdRoot?.toXpub ? [{
         XPUB: state.hdRoot.toXpub(),
         LABEL: '',
       }] : []),
+      // X25519 encryption key
       {
         PUBLIC_KEY: toBase64(state.wallet.x25519.publicKey),
         LABEL: 'X25519',
       },
-      {
-        PUBLIC_KEY: toBase64(state.wallet.ed25519.publicKey),
-        LABEL: "Ed25519 m/44'/501'/0'/0/0",
-      },
-      {
-        PUBLIC_KEY: toBase64(state.wallet.secp256k1.publicKey),
-        KEY_ADDRESS: state.addresses.btc || undefined,
-        LABEL: "secp256k1 m/44'/0'/0'/0/0",
-      },
+      // 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: '' }];
@@ -2352,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);
@@ -2773,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');
@@ -2848,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();
   });
-  $('hd-account')?.addEventListener('input', () => {
-    updatePathDisplay();
-    deriveAndDisplayAddress();
-    updateEncryptionTab();
+  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();
+  });
+  $('wallet-export-btn-main')?.addEventListener('click', () => {
+    closeWalletActionMenus();
+    showExportView();
+  });
+  $('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();
   });
-  $('hd-index')?.addEventListener('input', () => {
-    updatePathDisplay();
-    deriveAndDisplayAddress();
-    updateEncryptionTab();
+  // 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
@@ -3054,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');
@@ -3117,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);
   }