@glyphteck/veyl 0.51.0 → 0.55.0

package/dist/account.js

@@ -6346,10 +6346,10 @@ var domains = Object.freeze({
 var origins = Object.freeze({
   root: `https://${domains.root}`,
   rootDev: `https://${domains.rootDev}`,
-  rootDevWeb: `https://${domains.rootDev}:3001`,
   veyl: `https://${domains.veyl}`,
   veylDev: `https://${domains.veylDev}`,
-  veylDevWeb: `https://${domains.veylDev}:3000`
+  veylDevWeb: `https://${domains.veylDev}:3000`,
+  veylDevFeatureWeb: `https://${domains.veylDev}:3001`
 });
 var appDomains = Object.freeze([
   domains.veyl
@@ -7143,6 +7143,84 @@ function clearSettingsKey(key) {
   cleanBytes(key);
 }
 
+// ../../core/utils/number.js
+function nonNegativeNumber(value, fallback) {
+  const next = Number(value);
+  return Number.isFinite(next) && next >= 0 ? next : fallback;
+}
+function positiveNumber(value, fallback) {
+  const next = Number(value);
+  return Number.isFinite(next) && next > 0 ? next : fallback;
+}
+function positiveInt(value, fallback) {
+  const next = Math.trunc(Number(value));
+  return Number.isFinite(next) && next > 0 ? next : fallback;
+}
+function nonNegativeInt(value, fallback) {
+  const next = Math.trunc(Number(value));
+  return Number.isFinite(next) && next >= 0 ? next : fallback;
+}
+
+// ../../core/utils/async.js
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, nonNegativeNumber(ms, 0)));
+}
+function createOwnedWaits() {
+  const waits = new Set;
+  let closed = false;
+  const wait = (schedule, cancel) => new Promise((resolve) => {
+    if (closed) {
+      resolve();
+      return;
+    }
+    const pending = { cancel, id: null, resolve };
+    pending.id = schedule(() => {
+      waits.delete(pending);
+      resolve();
+    });
+    waits.add(pending);
+  });
+  return {
+    delay(ms) {
+      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(ms, 0)), (id) => globalThis.clearTimeout(id));
+    },
+    idle({ timeout = 0, delay = 0 } = {}) {
+      const requestIdle = globalThis.requestIdleCallback?.bind(globalThis);
+      const cancelIdle = globalThis.cancelIdleCallback?.bind(globalThis);
+      if (typeof requestIdle === "function" && typeof cancelIdle === "function") {
+        return wait((done) => requestIdle(done, { timeout: nonNegativeNumber(timeout, 0) }), cancelIdle);
+      }
+      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(delay, 0)), (id) => globalThis.clearTimeout(id));
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      for (const pending of waits) {
+        pending.cancel(pending.id);
+        pending.resolve();
+      }
+      waits.clear();
+    }
+  };
+}
+async function yieldToUi() {
+  if (typeof requestAnimationFrame === "function") {
+    await new Promise((resolve) => requestAnimationFrame(resolve));
+  }
+  await sleep(0);
+}
+function waitForIdle({ timeout = 0, delay = 0 } = {}) {
+  return new Promise((resolve) => {
+    const idle = globalThis.requestIdleCallback?.bind(globalThis);
+    if (typeof idle === "function") {
+      idle(() => resolve(), { timeout: nonNegativeNumber(timeout, 0) });
+      return;
+    }
+    globalThis.setTimeout(resolve, nonNegativeNumber(delay, 0));
+  });
+}
+
 // ../../core/crypto/sign.js
 "use client";
 var CHAT_SIGNING_SCOPE = "chat-actor-sign-v2";
@@ -8067,6 +8145,8 @@ async function openVaultAccountSession(vault, password, options = {}) {
     mark(diag, "vault.unlock.decrypt.done", { elapsedMs: Date.now() - decryptStartedAt, source });
     onStage?.("seed-decrypted");
     notifySeedDecrypted(onSeedDecrypted, diag, source);
+    await yieldToUi();
+    requireCurrent(isCurrent);
     onStage?.("deriving");
     const deriveStartedAt = Date.now();
     const registry = await openSecretRegistry(masterSeed, registryEnvelope);
@@ -8334,12 +8414,9 @@ function nextBanRefreshMs(banned, keys = ["full", "chat"], now = Date.now()) {
 }
 
 // ../../core/profile.js
-var BOT_PROFILE_MARKER = "bot";
+var BOT_PROFILE_MARKER = "glyphteck";
 function readBotMarker(profile) {
-  const bot = profile?.bot;
-  if (!bot)
-    return null;
-  return typeof bot === "string" ? bot : BOT_PROFILE_MARKER;
+  return profile?.bot === BOT_PROFILE_MARKER ? BOT_PROFILE_MARKER : null;
 }
 function hasPeerKeys(profile) {
   return !!(profile?.walletPK || profile?.chatPK);
@@ -9385,24 +9462,6 @@ async function makeSharedFileUploadPayload(data, { contentType = "application/oc
   }
 }
 
-// ../../core/utils/number.js
-function nonNegativeNumber(value, fallback) {
-  const next = Number(value);
-  return Number.isFinite(next) && next >= 0 ? next : fallback;
-}
-function positiveNumber(value, fallback) {
-  const next = Number(value);
-  return Number.isFinite(next) && next > 0 ? next : fallback;
-}
-function positiveInt(value, fallback) {
-  const next = Math.trunc(Number(value));
-  return Number.isFinite(next) && next > 0 ? next : fallback;
-}
-function nonNegativeInt(value, fallback) {
-  const next = Math.trunc(Number(value));
-  return Number.isFinite(next) && next >= 0 ? next : fallback;
-}
-
 // ../../core/chat/messages/files.js
 function hasLocalFileRef(msg) {
   if (!hasText(msg?.p) || !hasText(msg?.k)) {
@@ -12412,8 +12471,8 @@ var HIDDEN_TRANSFER_STATUSES = new Set(["TRANSFER_STATUS_EXPIRED", "TRANSFER_STA
 var LIGHTNING_RECEIVE_DONE_STATUSES = new Set(["transfer_completed", "lightning_payment_received", "payment_preimage_recovered", "completed"]);
 var WALLET_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_TRANSFER_CODE]);
 var WALLET_TRANSFER_TYPES = new Set([TRANSFER_TYPE_TRANSFER]);
-var WITHDRAWAL_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT_CODE]);
-var WITHDRAWAL_TRANSFER_TYPES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT]);
+var BITCOIN_PAYMENT_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT_CODE]);
+var BITCOIN_PAYMENT_TRANSFER_TYPES = new Set([TRANSFER_TYPE_COOPERATIVE_EXIT]);
 var BITCOIN_DEPOSIT_TYPE_CODES = new Set;
 var BITCOIN_DEPOSIT_TYPES = new Set([TRANSFER_TYPE_BITCOIN_DEPOSIT]);
 var FUNDING_TRANSFER_TYPE_CODES = new Set([TRANSFER_TYPE_UTXO_SWAP_CODE]);
@@ -12447,8 +12506,8 @@ function isPendingTransfer(tx) {
 function isWalletTransfer(tx) {
   return hasTransferType(tx, WALLET_TRANSFER_TYPES, WALLET_TRANSFER_TYPE_CODES);
 }
-function isWithdrawalTransfer(tx) {
-  return hasTransferType(tx, WITHDRAWAL_TRANSFER_TYPES, WITHDRAWAL_TRANSFER_TYPE_CODES);
+function isBitcoinPaymentTransfer(tx) {
+  return hasTransferType(tx, BITCOIN_PAYMENT_TRANSFER_TYPES, BITCOIN_PAYMENT_TRANSFER_TYPE_CODES);
 }
 function isFundingTransfer(tx) {
   if (hasTransferType(tx, BITCOIN_DEPOSIT_TYPES, BITCOIN_DEPOSIT_TYPE_CODES)) {
@@ -12464,7 +12523,7 @@ function isVisibleTransferStatus(tx) {
   return !status || !HIDDEN_TRANSFER_STATUSES.has(status);
 }
 function isVisibleTransfer(tx) {
-  return isVisibleTransferStatus(tx) && (isWalletTransfer(tx) || isFundingTransfer(tx) || isWithdrawalTransfer(tx));
+  return isVisibleTransferStatus(tx) && (isWalletTransfer(tx) || isFundingTransfer(tx) || isBitcoinPaymentTransfer(tx));
 }
 function isClaimablePendingTransfer(tx, types = null) {
   if (Array.isArray(types) && types.length && !types.includes(tx?.type)) {
@@ -15939,66 +15998,6 @@ function sameHead(a, b) {
   return a?.from === b?.from && a?.cid === b?.cid;
 }
 
-// ../../core/utils/async.js
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, nonNegativeNumber(ms, 0)));
-}
-function createOwnedWaits() {
-  const waits = new Set;
-  let closed = false;
-  const wait = (schedule, cancel) => new Promise((resolve) => {
-    if (closed) {
-      resolve();
-      return;
-    }
-    const pending = { cancel, id: null, resolve };
-    pending.id = schedule(() => {
-      waits.delete(pending);
-      resolve();
-    });
-    waits.add(pending);
-  });
-  return {
-    delay(ms) {
-      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(ms, 0)), (id) => globalThis.clearTimeout(id));
-    },
-    idle({ timeout = 0, delay = 0 } = {}) {
-      const requestIdle = globalThis.requestIdleCallback?.bind(globalThis);
-      const cancelIdle = globalThis.cancelIdleCallback?.bind(globalThis);
-      if (typeof requestIdle === "function" && typeof cancelIdle === "function") {
-        return wait((done) => requestIdle(done, { timeout: nonNegativeNumber(timeout, 0) }), cancelIdle);
-      }
-      return wait((done) => globalThis.setTimeout(done, nonNegativeNumber(delay, 0)), (id) => globalThis.clearTimeout(id));
-    },
-    close() {
-      if (closed)
-        return;
-      closed = true;
-      for (const pending of waits) {
-        pending.cancel(pending.id);
-        pending.resolve();
-      }
-      waits.clear();
-    }
-  };
-}
-async function yieldToUi() {
-  if (typeof requestAnimationFrame === "function") {
-    await new Promise((resolve) => requestAnimationFrame(resolve));
-  }
-  await sleep(0);
-}
-function waitForIdle({ timeout = 0, delay = 0 } = {}) {
-  return new Promise((resolve) => {
-    const idle = globalThis.requestIdleCallback?.bind(globalThis);
-    if (typeof idle === "function") {
-      idle(() => resolve(), { timeout: nonNegativeNumber(timeout, 0) });
-      return;
-    }
-    globalThis.setTimeout(resolve, nonNegativeNumber(delay, 0));
-  });
-}
-
 // ../../core/chat/messages/payloadlog.js
 var CHAT_PAYLOAD_DIAG_ENV = globalThis.process?.env || {};
 var CHAT_PAYLOAD_DIAG_DEV = typeof globalThis !== "undefined" && globalThis.__DEV__ === true || CHAT_PAYLOAD_DIAG_ENV?.NODE_ENV === "development";
@@ -21194,7 +21193,7 @@ var FEE_RATE_FALLBACKS = Object.freeze({
   noPriority: Object.freeze(["low", "medium", "high"]),
   average: Object.freeze(["medium", "low", "high"])
 });
-var WITHDRAWAL_FEE_FIELDS = Object.freeze({
+var BITCOIN_PAYMENT_FEE_FIELDS = Object.freeze({
   FAST: Object.freeze({ user: "userFeeFast", l1: "l1BroadcastFeeFast" }),
   MEDIUM: Object.freeze({ user: "userFeeMedium", l1: "l1BroadcastFeeMedium" }),
   SLOW: Object.freeze({ user: "userFeeSlow", l1: "l1BroadcastFeeSlow" })
@@ -21240,12 +21239,12 @@ function getCurrencyAmountSats(amount) {
   }
   return value;
 }
-function getWithdrawalFeeBreakdown(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
+function getBitcoinPaymentFeeBreakdown(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
   if (!feeQuote) {
     return null;
   }
   const speed = getExitSpeed(exitSpeed);
-  const fields = WITHDRAWAL_FEE_FIELDS[speed];
+  const fields = BITCOIN_PAYMENT_FEE_FIELDS[speed];
   const userFeeSats = getCurrencyAmountSats(feeQuote[fields.user]);
   const l1BroadcastFeeSats = getCurrencyAmountSats(feeQuote[fields.l1]);
   return {
@@ -21257,16 +21256,16 @@ function getWithdrawalFeeBreakdown(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
     expiresAt: feeQuote.expiresAt ?? null
   };
 }
-function getWithdrawalFeeAmountSats(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
-  return getWithdrawalFeeBreakdown(feeQuote, exitSpeed)?.feeAmountSats ?? null;
+function getBitcoinPaymentFeeAmountSats(feeQuote, exitSpeed = DEFAULT_EXIT_SPEED) {
+  return getBitcoinPaymentFeeBreakdown(feeQuote, exitSpeed)?.feeAmountSats ?? null;
 }
-function normalizeWithdrawalFeeQuote(feeQuote) {
+function normalizeBitcoinPaymentFeeQuote(feeQuote) {
   if (!feeQuote) {
     return null;
   }
   const speeds = {};
   for (const speed of EXIT_SPEEDS) {
-    speeds[speed] = getWithdrawalFeeBreakdown(feeQuote, speed);
+    speeds[speed] = getBitcoinPaymentFeeBreakdown(feeQuote, speed);
   }
   return {
     id: feeQuote.id ?? null,
@@ -23855,59 +23854,6 @@ async function createLightningInvoice(wallet, { amountSats = 0, memo, expirySeco
     return { success: false, error };
   }
 }
-async function quoteLightningFees(wallet, { invoice, amountSats } = {}) {
-  if (!wallet) {
-    return { success: false, error: new Error("wallet not ready") };
-  }
-  const encodedInvoice = cleanText(invoice);
-  if (!encodedInvoice) {
-    return { success: false, error: new Error("lightning invoice required") };
-  }
-  try {
-    const params = { encodedInvoice };
-    if (amountSats != null) {
-      params.amountSats = toSafeSats(amountSats);
-    }
-    const feeAmountSats = await wallet.getLightningSendFeeEstimate(params);
-    return {
-      success: true,
-      feeAmountSats,
-      fees: normalizeLightningFeeEstimate(feeAmountSats)
-    };
-  } catch (error) {
-    return { success: false, error };
-  }
-}
-async function sendLightningPayment(wallet, { invoice, maxFeeSats, preferSpark = false, amountSatsToSend, idempotencyKey } = {}) {
-  if (!wallet) {
-    return { success: false, error: new Error("wallet not ready") };
-  }
-  const encodedInvoice = cleanText(invoice);
-  if (!encodedInvoice) {
-    return { success: false, error: new Error("lightning invoice required") };
-  }
-  try {
-    const params = {
-      invoice: encodedInvoice,
-      maxFeeSats: toSafeNonNegativeSats(maxFeeSats, "maxFeeSats"),
-      preferSpark: !!preferSpark
-    };
-    if (amountSatsToSend != null) {
-      params.amountSatsToSend = toSafeSats(amountSatsToSend, "amountSatsToSend");
-    }
-    if (idempotencyKey) {
-      params.idempotencyKey = idempotencyKey;
-    }
-    const payment = await wallet.payLightningInvoice(params);
-    return {
-      success: true,
-      payment,
-      result: normalizeLightningPaymentResult(payment)
-    };
-  } catch (error) {
-    return { success: false, error };
-  }
-}
 async function getLightningReceiveRequest(wallet, id) {
   if (!wallet) {
     return { success: false, error: new Error("wallet not ready") };
@@ -23948,17 +23894,9 @@ async function getLightningSendRequest(wallet, id) {
 }
 
 // ../../core/wallet/lightning.js
-function createLightning({ wallet, updateWalletData }) {
+function createLightning({ wallet }) {
   return {
     createLightningInvoice: (params) => createLightningInvoice(wallet, params),
-    quoteLightningFees: (params) => quoteLightningFees(wallet, params),
-    async sendLightningPayment(params) {
-      const result = await sendLightningPayment(wallet, params);
-      if (result.success) {
-        await updateWalletData({ reason: "lightning-send" });
-      }
-      return result;
-    },
     getLightningReceiveRequest: (id) => getLightningReceiveRequest(wallet, id),
     getLightningSendRequest: (id) => getLightningSendRequest(wallet, id)
   };
@@ -24456,56 +24394,6 @@ function createWalletReadyDiag({ wallet, getBalanceState, getTransferState, diag
   };
 }
 
-// ../../core/wallet/privacy.js
-var PRIVACY_SYNC_DELAY_MS = WALLET_BOOT_CACHED_REFRESH_DELAY_MS * 2;
-function createWalletPrivacy({ wallet, ghostWallet, diag }) {
-  let desiredPrivacy = ghostWallet === true;
-  let revision = 0;
-  let closed = false;
-  let privacySync = Promise.resolve();
-  const waits = createOwnedWaits();
-  const setGhostWallet = (nextGhostWallet) => {
-    const nextDesiredPrivacy = nextGhostWallet === true;
-    if (revision > 0 && desiredPrivacy === nextDesiredPrivacy) {
-      return privacySync;
-    }
-    desiredPrivacy = nextDesiredPrivacy;
-    const requestRevision = ++revision;
-    if (!wallet || typeof wallet.setPrivacyEnabled !== "function" || closed) {
-      return privacySync;
-    }
-    privacySync = privacySync.catch(() => {}).then(async () => {
-      await waits.delay(PRIVACY_SYNC_DELAY_MS);
-      if (closed || requestRevision !== revision) {
-        return;
-      }
-      await waits.idle({ timeout: PRIVACY_SYNC_DELAY_MS, delay: PRIVACY_SYNC_DELAY_MS });
-      if (closed || requestRevision !== revision) {
-        return;
-      }
-      const startedAt = Date.now();
-      const desired = desiredPrivacy;
-      markDiag(diag, "wallet.privacy.start", { ghostWallet: desired });
-      await wallet.setPrivacyEnabled(desired);
-      markDone(diag, "wallet.privacy", startedAt, { changed: true });
-    }).catch((error) => {
-      markDiag(diag, "wallet.privacy.error", { code: error?.code || "", message: error?.message || String(error) });
-    });
-    return privacySync;
-  };
-  setGhostWallet(ghostWallet);
-  return {
-    setGhostWallet,
-    close() {
-      if (closed)
-        return;
-      closed = true;
-      revision += 1;
-      waits.close();
-    }
-  };
-}
-
 // ../../core/wallet/spark.js
 var import_bech32 = __toESM(require_dist(), 1);
 var SPARK_ADDRESS_PREFIX = Object.freeze({
@@ -24550,7 +24438,58 @@ function walletPKtoSparkAddress(walletPK, network) {
   return import_bech32.bech32m.encode(getSparkAddressPrefix(network), import_bech32.bech32m.toWords(payload), 1500);
 }
 
-// ../../core/wallet/send.js
+// ../../core/wallet/payment.js
+var PAYMENT_KIND_BITCOIN = "bitcoin";
+var PAYMENT_KIND_LIGHTNING = "lightning";
+var PAYMENT_KIND_SPARK = "spark";
+var PAYMENT_KIND_SPARK_INVOICE = "spark_invoice";
+var PAYMENT_STATE_PREPARED = "prepared";
+var PAYMENT_KINDS = new Set([
+  PAYMENT_KIND_BITCOIN,
+  PAYMENT_KIND_LIGHTNING,
+  PAYMENT_KIND_SPARK,
+  PAYMENT_KIND_SPARK_INVOICE
+]);
+var P2PKH_DUST_SATS = 546;
+var P2SH_DUST_SATS = 540;
+var P2WPKH_DUST_SATS = 294;
+var SEGWIT_SCRIPT_DUST_SATS = 330;
+function paymentKind(value) {
+  const kind = cleanText(value).toLowerCase();
+  if (!PAYMENT_KINDS.has(kind)) {
+    throw new Error("unsupported payment kind");
+  }
+  return kind;
+}
+function paymentDestination(value) {
+  const destination = cleanText(value);
+  if (!destination) {
+    throw new Error("payment destination required");
+  }
+  return destination;
+}
+function optionalPaymentAmount(value) {
+  return value == null ? null : toSafeSats(value);
+}
+function normalizeIntent(intent = {}) {
+  const kind = paymentKind(intent.kind);
+  const destination = paymentDestination(intent.destination);
+  const amountSats = optionalPaymentAmount(intent.amountSats);
+  if ((kind === PAYMENT_KIND_BITCOIN || kind === PAYMENT_KIND_SPARK) && amountSats == null) {
+    throw new Error("payment amount required");
+  }
+  return {
+    kind,
+    destination,
+    amountSats,
+    variableAmount: intent.variableAmount === true,
+    preferSpark: intent.preferSpark === true,
+    idempotencyKey: cleanText(intent.idempotencyKey) || null,
+    maxFeeSats: intent.maxFeeSats == null ? null : toSafeNonNegativeSats(intent.maxFeeSats, "maxFeeSats"),
+    exitSpeed: getExitSpeed(intent.exitSpeed),
+    deductFeeFromAmount: intent.deductFeeFromAmount !== false
+  };
+}
 function firstSparkInvoiceError(result) {
   return result?.invalidInvoices?.[0]?.error || result?.satsTransactionErrors?.[0]?.error || result?.tokenTransactionErrors?.[0]?.error || null;
 }
@@ -24566,137 +24505,345 @@ function publicSparkInvoiceResult(transfer) {
     amountSats: Number.isSafeInteger(transfer?.totalValue) ? transfer.totalValue : null
   };
 }
-function createWalletSend({ wallet, network, updateWalletData, refreshBalance = null, rememberTransfer, refreshPendingTransfers = null, sentTransferRefreshDelayMs = null, beginSdkActivity = null, diag }) {
-  const refreshTimers = new Set;
-  let closed = false;
-  const sendMoneyWithSpark = async (receiverWalletPK, amountSats) => {
-    if (!wallet || closed) {
-      throw new Error("wallet not ready");
+function getBitcoinPaymentMinimumReceiveSats(addressInput) {
+  const address = cleanText(addressInput).toLowerCase();
+  if (address.startsWith("1"))
+    return P2PKH_DUST_SATS;
+  if (address.startsWith("3"))
+    return P2SH_DUST_SATS;
+  const p2wpkhLength = address.startsWith("bcrt1q") ? 44 : 42;
+  if ((address.startsWith("bc1q") || address.startsWith("bcrt1q")) && address.length === p2wpkhLength) {
+    return P2WPKH_DUST_SATS;
+  }
+  return SEGWIT_SCRIPT_DUST_SATS;
+}
+function getBitcoinPaymentAmounts(payment) {
+  const amountSats = toSafeSats(payment?.amountSats);
+  const feeAmountSats = toSafeNonNegativeSats(payment?.feeAmountSats ?? 0, "feeAmountSats");
+  const deductFeeFromAmount = payment?.deductFeeFromAmount !== false;
+  const receiveAmountSats = deductFeeFromAmount ? Math.max(0, amountSats - feeAmountSats) : amountSats;
+  const sendAmountSats = deductFeeFromAmount ? amountSats : amountSats + feeAmountSats;
+  return {
+    sendAmountSats,
+    receiveAmountSats,
+    feeAmountSats
+  };
+}
+function assertBitcoinPaymentReceivesFunds(payment) {
+  const { receiveAmountSats } = getBitcoinPaymentAmounts(payment);
+  const minimumReceiveAmountSats = getBitcoinPaymentMinimumReceiveSats(payment?.destination);
+  if (receiveAmountSats < minimumReceiveAmountSats) {
+    throw new Error(`bitcoin payment would create a dust output below ${minimumReceiveAmountSats} sats`);
+  }
+}
+function bitcoinPaymentReview(intent, feeQuote) {
+  const feeQuoteId = feeQuote?.id ?? null;
+  const feeAmountSats = getBitcoinPaymentFeeAmountSats(feeQuote, intent.exitSpeed);
+  if (!feeQuoteId || feeAmountSats == null) {
+    throw new Error("bitcoin payment fee quote unavailable");
+  }
+  const sparkFees = normalizeBitcoinPaymentFeeQuote(feeQuote);
+  const payment = {
+    ...intent,
+    state: PAYMENT_STATE_PREPARED,
+    feeQuote,
+    feeQuoteId,
+    feeAmountSats,
+    fees: { spark: sparkFees },
+    expiresAt: sparkFees?.expiresAt ?? feeQuote.expiresAt ?? null
+  };
+  assertBitcoinPaymentReceivesFunds(payment);
+  return Object.freeze(payment);
+}
+function preparedPayment(intent, extra = {}) {
+  return Object.freeze({
+    ...intent,
+    state: PAYMENT_STATE_PREPARED,
+    fees: null,
+    expiresAt: null,
+    ...extra
+  });
+}
+async function prepare(wallet, network, paymentInput) {
+  if (!wallet) {
+    throw new Error("wallet not ready");
+  }
+  const intent = normalizeIntent(paymentInput);
+  if (intent.kind === PAYMENT_KIND_BITCOIN) {
+    if (!isAddressOnNetwork(intent.destination, network)) {
+      throw new Error(`refusing to pay - address is not a ${network} address`);
     }
-    const startedAt = Date.now();
-    markDiag(diag, "wallet.send.start", {});
-    const endSdkActivity = typeof beginSdkActivity === "function" ? beginSdkActivity("send") : null;
-    try {
-      const receiverSparkAddress = walletPKtoSparkAddress(receiverWalletPK, network);
-      const tx = await wallet.transfer({
-        receiverSparkAddress,
-        amountSats: toSafeSats(amountSats)
-      });
-      endSdkActivity?.();
-      markDone(diag, "wallet.send.sdk", startedAt, { hasTransfer: !!tx?.id });
-      const rememberStartedAt = Date.now();
-      await rememberTransfer?.(tx, { pending: true });
-      markDone(diag, "wallet.send.remember", rememberStartedAt, { hasTransfer: !!tx?.id });
-      await refreshBalance?.();
-      const refreshDelayMs = Number(sentTransferRefreshDelayMs);
-      if (!closed && tx?.id && typeof refreshPendingTransfers === "function" && Number.isFinite(refreshDelayMs) && refreshDelayMs >= 0) {
-        markDiag(diag, "wallet.send.refresh.schedule", { delayMs: refreshDelayMs });
-        const timer = setTimeout(() => {
-          refreshTimers.delete(timer);
-          if (closed)
-            return;
-          markDiag(diag, "wallet.send.refresh.start", {});
-          refreshPendingTransfers([tx.id]);
-        }, refreshDelayMs);
-        refreshTimers.add(timer);
+    const feeQuote = await wallet.getWithdrawalFeeQuote({
+      amountSats: intent.amountSats,
+      withdrawalAddress: intent.destination
+    });
+    return bitcoinPaymentReview(intent, feeQuote);
+  }
+  if (intent.kind === PAYMENT_KIND_LIGHTNING) {
+    let maxFeeSats = intent.maxFeeSats;
+    let fees = maxFeeSats == null ? null : normalizeLightningFeeEstimate(maxFeeSats);
+    if (maxFeeSats == null) {
+      const estimateParams = { encodedInvoice: intent.destination };
+      if (intent.variableAmount && intent.amountSats != null) {
+        estimateParams.amountSats = intent.amountSats;
       }
-      markDone(diag, "wallet.send", startedAt, { hasTransfer: !!tx?.id });
-      return tx?.id;
-    } catch (error) {
-      endSdkActivity?.();
-      markError(diag, "wallet.send", startedAt, error);
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`failed to send money: ${message}`, { cause: error });
+      maxFeeSats = await wallet.getLightningSendFeeEstimate(estimateParams);
+      fees = normalizeLightningFeeEstimate(maxFeeSats);
     }
+    return preparedPayment(intent, { maxFeeSats, fees });
+  }
+  return preparedPayment(intent);
+}
+function normalizePreparedPayment(paymentInput, network) {
+  const intent = normalizeIntent(paymentInput);
+  if (paymentInput?.state !== PAYMENT_STATE_PREPARED) {
+    throw new Error("prepared payment required");
+  }
+  if (intent.kind !== PAYMENT_KIND_BITCOIN) {
+    return preparedPayment(intent, {
+      fees: paymentInput.fees || null,
+      expiresAt: paymentInput.expiresAt ?? null
+    });
+  }
+  if (!isAddressOnNetwork(intent.destination, network)) {
+    throw new Error(`refusing to pay - address is not a ${network} address`);
+  }
+  const feeQuoteId = cleanText(paymentInput.feeQuoteId);
+  if (!feeQuoteId) {
+    throw new Error("bitcoin payment fee quote missing");
+  }
+  const payment = {
+    ...intent,
+    state: PAYMENT_STATE_PREPARED,
+    feeQuote: paymentInput.feeQuote || null,
+    feeQuoteId,
+    feeAmountSats: toSafeNonNegativeSats(paymentInput.feeAmountSats, "feeAmountSats"),
+    fees: paymentInput.fees || null,
+    expiresAt: paymentInput.expiresAt ?? null
+  };
+  assertBitcoinPaymentReceivesFunds(payment);
+  return Object.freeze(payment);
+}
+async function sendBitcoin(wallet, walletPK, network, payment, rememberTransfer) {
+  if (!isAddressOnNetwork(payment.destination, network)) {
+    throw new Error(`refusing to pay - address is not a ${network} address`);
+  }
+  if (!payment.feeQuoteId || payment.feeAmountSats == null) {
+    throw new Error("bitcoin payment review missing");
+  }
+  assertBitcoinPaymentReceivesFunds(payment);
+  const tx = await wallet.withdraw({
+    onchainAddress: payment.destination,
+    amountSats: payment.amountSats,
+    exitSpeed: payment.exitSpeed,
+    feeQuoteId: payment.feeQuoteId,
+    feeAmountSats: payment.feeAmountSats,
+    deductFeeFromWithdrawalAmount: payment.deductFeeFromAmount
+  });
+  const transferId = tx?.transfer?.sparkId || tx?.transfer?.id || null;
+  if (transferId) {
+    const createdTime = tx?.createdAt || new Date().toISOString();
+    await rememberTransfer?.({
+      id: transferId,
+      senderIdentityPublicKey: walletPK,
+      receiverIdentityPublicKey: "",
+      status: "TRANSFER_STATUS_SENDER_INITIATED",
+      totalValue: payment.amountSats,
+      createdTime,
+      updatedTime: tx?.updatedAt || createdTime,
+      type: "COOPERATIVE_EXIT",
+      transferDirection: "OUTGOING"
+    }, {
+      pending: true,
+      bitcoinAddress: payment.destination,
+      bitcoinTxid: tx?.coopExitTxid || null
+    });
+  }
+  return {
+    id: transferId || tx?.id || tx?.coopExitTxid || null,
+    result: tx
   };
-  const payExternalInvoice = async ({ type, invoice, amountSats, variableAmount = false } = {}) => {
+}
+function createPayment({
+  wallet,
+  walletPK,
+  network,
+  updateWalletData,
+  refreshBalance = null,
+  rememberTransfer,
+  refreshPendingTransfers = null,
+  sentTransferRefreshDelayMs = null,
+  beginSdkActivity = null,
+  diag = null
+}) {
+  const refreshTimers = new Set;
+  let closed = false;
+  const assertReady = () => {
     if (!wallet || closed) {
       throw new Error("wallet not ready");
     }
-    const value = cleanText(invoice);
-    if (!value) {
-      throw new Error("invoice required");
+  };
+  const preparePayment = async (intent) => {
+    assertReady();
+    return prepare(wallet, network, intent);
+  };
+  const scheduleTransferRefresh = (id) => {
+    const refreshDelayMs = Number(sentTransferRefreshDelayMs);
+    if (closed || !id || typeof refreshPendingTransfers !== "function" || !Number.isFinite(refreshDelayMs) || refreshDelayMs < 0) {
+      return;
+    }
+    markDiag(diag, "wallet.send.refresh.schedule", { delayMs: refreshDelayMs });
+    const timer = setTimeout(() => {
+      refreshTimers.delete(timer);
+      if (closed)
+        return;
+      markDiag(diag, "wallet.send.refresh.start", {});
+      refreshPendingTransfers([id]);
+    }, refreshDelayMs);
+    refreshTimers.add(timer);
+  };
+  const sendPayment = async (paymentInput) => {
+    assertReady();
+    if (paymentInput?.kind === PAYMENT_KIND_BITCOIN && paymentInput?.state !== PAYMENT_STATE_PREPARED) {
+      throw new Error("bitcoin payment must be reviewed before sending");
     }
+    const payment = paymentInput?.state === PAYMENT_STATE_PREPARED ? normalizePreparedPayment(paymentInput, network) : await preparePayment(paymentInput);
     const startedAt = Date.now();
-    markDiag(diag, "wallet.externalPay.start", { type });
-    if (type === "lightning") {
-      try {
-        const sendAmountSats = variableAmount ? toSafeSats(amountSats, "amountSatsToSend") : null;
-        const estimateParams = {
-          encodedInvoice: value,
-          ...sendAmountSats != null ? { amountSats: sendAmountSats } : {}
-        };
-        const feeAmountSats = await wallet.getLightningSendFeeEstimate(estimateParams);
-        const fees = normalizeLightningFeeEstimate(feeAmountSats);
-        const payment = await wallet.payLightningInvoice({
-          invoice: value,
-          maxFeeSats: fees.feeAmountSats,
-          preferSpark: true,
-          ...sendAmountSats != null ? { amountSatsToSend: sendAmountSats } : {}
+    const diagKind = payment.kind;
+    markDiag(diag, "wallet.payment.start", { kind: diagKind });
+    const endSdkActivity = typeof beginSdkActivity === "function" ? beginSdkActivity("payment") : null;
+    try {
+      let outcome;
+      if (payment.kind === PAYMENT_KIND_SPARK) {
+        if (sameText(payment.destination, walletPK)) {
+          throw new Error("cannot send money to the same wallet");
+        }
+        const tx = await wallet.transfer({
+          receiverSparkAddress: walletPKtoSparkAddress(payment.destination, network),
+          amountSats: payment.amountSats
+        });
+        await rememberTransfer?.(tx, { pending: true });
+        await refreshBalance?.();
+        scheduleTransferRefresh(tx?.id);
+        outcome = { id: tx?.id || null, result: tx };
+      } else if (payment.kind === PAYMENT_KIND_LIGHTNING) {
+        const sent = await wallet.payLightningInvoice({
+          invoice: payment.destination,
+          maxFeeSats: payment.maxFeeSats,
+          preferSpark: payment.preferSpark,
+          ...payment.variableAmount && payment.amountSats != null ? { amountSatsToSend: payment.amountSats } : {},
+          ...payment.idempotencyKey ? { idempotencyKey: payment.idempotencyKey } : {}
         });
-        const result = normalizeLightningPaymentResult(payment);
+        const result = normalizeLightningPaymentResult(sent);
         if (result?.kind === "spark" && result?.transfer) {
           await rememberTransfer?.(result.transfer, { pending: true });
         } else {
-          await rememberTransfer?.(result?.id || payment?.id);
+          await rememberTransfer?.(result?.id || sent?.id);
           await updateWalletData({ reason: "external-lightning-send" });
         }
-        markDone(diag, "wallet.externalPay", startedAt, { type, hasTransfer: !!result?.transfer });
-        return {
-          id: result?.id || payment?.id || null,
-          payment,
-          result,
-          fees
-        };
-      } catch (error) {
-        markError(diag, "wallet.externalPay", startedAt, error, { type });
-        throw error;
-      }
-    }
-    if (type === "spark") {
-      try {
-        const safeAmountSats = amountSats != null ? toSafeSats(amountSats, "amountSats") : null;
+        outcome = { id: result?.id || sent?.id || null, result, raw: sent };
+      } else if (payment.kind === PAYMENT_KIND_SPARK_INVOICE) {
         const result = await wallet.fulfillSparkInvoice([
           {
-            invoice: value,
-            ...safeAmountSats != null ? { amount: BigInt(safeAmountSats) } : {}
+            invoice: payment.destination,
+            ...payment.amountSats != null ? { amount: BigInt(payment.amountSats) } : {}
           }
         ]);
         const error = firstSparkInvoiceError(result);
-        if (error) {
+        if (error)
           throw error;
-        }
         const success = firstSparkInvoiceSuccess(result);
-        if (!success) {
+        if (!success)
           throw new Error("failed to pay spark invoice");
-        }
         const id = success.id || success.txid || null;
         await rememberTransfer?.(success.id ? success : id, { pending: true });
-        markDone(diag, "wallet.externalPay", startedAt, { type, hasTransfer: !!id });
-        return {
-          id,
-          result: publicSparkInvoiceResult(success)
-        };
-      } catch (error) {
-        markError(diag, "wallet.externalPay", startedAt, error, { type });
-        throw error;
+        outcome = { id, result: publicSparkInvoiceResult(success), raw: result };
+      } else if (payment.kind === PAYMENT_KIND_BITCOIN) {
+        outcome = await sendBitcoin(wallet, walletPK, network, payment, rememberTransfer);
+        await updateWalletData({ reason: "bitcoin-payment" });
+      } else {
+        throw new Error("unsupported payment kind");
       }
+      endSdkActivity?.();
+      markDone(diag, "wallet.payment", startedAt, { kind: diagKind, hasTransfer: !!outcome?.id });
+      return Object.freeze({
+        kind: payment.kind,
+        destination: payment.destination,
+        amountSats: payment.amountSats,
+        id: outcome?.id || null,
+        fees: payment.fees || null,
+        result: outcome?.result || null,
+        raw: outcome?.raw || null
+      });
+    } catch (error) {
+      endSdkActivity?.();
+      markError(diag, "wallet.payment", startedAt, error, { kind: diagKind });
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`failed to send payment: ${message}`, { cause: error });
     }
-    throw new Error("unsupported invoice type");
   };
   return {
-    sendMoneyWithSpark,
-    payExternalInvoice,
+    preparePayment,
+    sendPayment,
     close() {
       closed = true;
-      for (const timer of refreshTimers) {
+      for (const timer of refreshTimers)
         clearTimeout(timer);
-      }
       refreshTimers.clear();
     }
   };
 }
 
+// ../../core/wallet/privacy.js
+var PRIVACY_SYNC_DELAY_MS = WALLET_BOOT_CACHED_REFRESH_DELAY_MS * 2;
+function createWalletPrivacy({ wallet, ghostWallet, diag }) {
+  let desiredPrivacy = ghostWallet === true;
+  let revision = 0;
+  let closed = false;
+  let privacySync = Promise.resolve();
+  const waits = createOwnedWaits();
+  const setGhostWallet = (nextGhostWallet) => {
+    const nextDesiredPrivacy = nextGhostWallet === true;
+    if (revision > 0 && desiredPrivacy === nextDesiredPrivacy) {
+      return privacySync;
+    }
+    desiredPrivacy = nextDesiredPrivacy;
+    const requestRevision = ++revision;
+    if (!wallet || typeof wallet.setPrivacyEnabled !== "function" || closed) {
+      return privacySync;
+    }
+    privacySync = privacySync.catch(() => {}).then(async () => {
+      await waits.delay(PRIVACY_SYNC_DELAY_MS);
+      if (closed || requestRevision !== revision) {
+        return;
+      }
+      await waits.idle({ timeout: PRIVACY_SYNC_DELAY_MS, delay: PRIVACY_SYNC_DELAY_MS });
+      if (closed || requestRevision !== revision) {
+        return;
+      }
+      const startedAt = Date.now();
+      const desired = desiredPrivacy;
+      markDiag(diag, "wallet.privacy.start", { ghostWallet: desired });
+      await wallet.setPrivacyEnabled(desired);
+      markDone(diag, "wallet.privacy", startedAt, { changed: true });
+    }).catch((error) => {
+      markDiag(diag, "wallet.privacy.error", { code: error?.code || "", message: error?.message || String(error) });
+    });
+    return privacySync;
+  };
+  setGhostWallet(ghostWallet);
+  return {
+    setGhostWallet,
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      revision += 1;
+      waits.close();
+    }
+  };
+}
+
 // ../../core/wallet/history.js
 function transferPage(page, currentOffset, limit) {
   const transfers = Array.isArray(page?.transfers) ? page.transfers : [];
@@ -24775,7 +24922,7 @@ function compareRecentTransfer(a, b) {
   return String(b?.id || "").localeCompare(String(a?.id || ""));
 }
 function sameTransfer(left, right) {
-  return left?.id === right?.id && left?.status === right?.status && txCreatedMs(left) === txCreatedMs(right) && txUpdatedMs(left) === txUpdatedMs(right) && left?.totalValue === right?.totalValue && left?.type === right?.type && left?.transferDirection === right?.transferDirection && left?.senderIdentityPublicKey === right?.senderIdentityPublicKey && left?.receiverIdentityPublicKey === right?.receiverIdentityPublicKey;
+  return left?.id === right?.id && left?.status === right?.status && txCreatedMs(left) === txCreatedMs(right) && txUpdatedMs(left) === txUpdatedMs(right) && left?.totalValue === right?.totalValue && left?.type === right?.type && left?.transferDirection === right?.transferDirection && left?.senderIdentityPublicKey === right?.senderIdentityPublicKey && left?.receiverIdentityPublicKey === right?.receiverIdentityPublicKey && left?.bitcoinAddress === right?.bitcoinAddress && left?.bitcoinTxid === right?.bitcoinTxid;
 }
 function sameTransfers(a = [], b = []) {
   if (a === b) {
@@ -24817,10 +24964,13 @@ function satValue(value) {
   const amount = Number(value);
   return Number.isFinite(amount) ? amount : 0;
 }
-function compactTransfer(tx, { incoming = false } = {}) {
+function compactTransfer(tx, { incoming = false, bitcoinAddress = null, bitcoinTxid = null } = {}) {
   if (!tx?.id) {
     return null;
   }
+  const isBitcoinPayment = enumName(tx.type, TRANSFER_TYPE_BY_CODE) === "COOPERATIVE_EXIT";
+  const storedBitcoinAddress = String(bitcoinAddress || tx.bitcoinAddress || "").trim() || null;
+  const storedBitcoinTxid = String(bitcoinTxid || tx.bitcoinTxid || (isBitcoinPayment ? tx.userRequest?.coopExitTxid : "") || "").trim() || null;
   return {
     id: tx.id,
     senderIdentityPublicKey: hexKey(tx.senderIdentityPublicKey),
@@ -24830,11 +24980,13 @@ function compactTransfer(tx, { incoming = false } = {}) {
     createdTime: tx.createdTime,
     updatedTime: tx.updatedTime,
     type: enumName(tx.type, TRANSFER_TYPE_BY_CODE),
-    transferDirection: tx.transferDirection || (incoming ? "INCOMING" : undefined)
+    transferDirection: tx.transferDirection || (incoming ? "INCOMING" : undefined),
+    ...isBitcoinPayment && storedBitcoinAddress ? { bitcoinAddress: storedBitcoinAddress } : {},
+    ...isBitcoinPayment && storedBitcoinTxid ? { bitcoinTxid: storedBitcoinTxid } : {}
   };
 }
 function compactRememberedTransfer(tx, options = {}) {
-  const compact = compactTransfer(tx, { incoming: options?.incoming === true });
+  const compact = compactTransfer(tx, options);
   if (!compact) {
     return null;
   }
@@ -24908,12 +25060,30 @@ function getOldestAnyTransferMs(transfers = []) {
 function shouldReplaceTransfer(current, next) {
   return isPendingTransfer(current) && (!isPendingTransfer(next) || current?.status !== next?.status || txUpdatedMs(next) > txUpdatedMs(current));
 }
+function mergeTransferDetails(current, next) {
+  if (!current)
+    return next;
+  const base = shouldReplaceTransfer(current, next) ? next : current;
+  const bitcoinAddress = next?.bitcoinAddress || current.bitcoinAddress || null;
+  const bitcoinTxid = next?.bitcoinTxid || current.bitcoinTxid || null;
+  if (base === current && bitcoinAddress === current?.bitcoinAddress && bitcoinTxid === current?.bitcoinTxid) {
+    return current;
+  }
+  if (base === next && bitcoinAddress === next?.bitcoinAddress && bitcoinTxid === next?.bitcoinTxid) {
+    return next;
+  }
+  return {
+    ...base,
+    ...bitcoinAddress ? { bitcoinAddress } : {},
+    ...bitcoinTxid ? { bitcoinTxid } : {}
+  };
+}
 function indexTransfersById(transfers = []) {
   const byId = new Map;
   for (const tx of Array.isArray(transfers) ? transfers : []) {
     const id = String(tx?.id || "");
     if (id) {
-      byId.set(id, tx);
+      byId.set(id, mergeTransferDetails(byId.get(id), tx));
     }
   }
   return byId;
@@ -24925,7 +25095,7 @@ function hasMergeableTransferChanges(transfers = [], transferById = new Map) {
       continue;
     }
     const current = transferById.get(id);
-    if (!current || shouldReplaceTransfer(current, tx)) {
+    if (!current || mergeTransferDetails(current, tx) !== current) {
       return true;
     }
   }
@@ -24942,8 +25112,9 @@ function dedupeSortedTransfers(transfers = []) {
       continue;
     }
     const current = byId.get(id);
-    if (!current || shouldReplaceTransfer(current, tx)) {
-      byId.set(id, tx);
+    const merged = mergeTransferDetails(current, tx);
+    if (!current || merged !== current) {
+      byId.set(id, merged);
     }
   }
   return sortRecentTransfers([...byId.values()]);
@@ -25011,11 +25182,14 @@ function mergeCompactedTransferPage(current = [], pageTransfers = [], position =
   const updatedCurrent = replacements.size ? current.map((tx) => {
     const id = String(tx?.id || "");
     const replacement = id ? replacements.get(id) : null;
-    if (!replacement || !shouldReplaceTransfer(tx, replacement)) {
+    if (!replacement) {
       return tx;
     }
+    const merged = mergeTransferDetails(tx, replacement);
+    if (merged === tx)
+      return tx;
     changed = true;
-    return replacement;
+    return merged;
   }) : current;
   if (!newItems.length) {
     return changed ? updatedCurrent : current;
@@ -25038,7 +25212,8 @@ function mergeTransferPageForWallet(currentTransfers = [], pageTransfers = [], w
   return mergeCompactedTransferPage(current, page, position);
 }
 function mergeRecentSnapshotForWallet(currentTransfers = [], latestTransfers = [], walletPK) {
-  const latest = mergeTransferPageForWallet([], latestTransfers, walletPK, "append");
+  const currentById = new Map(currentTransfers.map((tx) => [String(tx?.id || ""), tx]));
+  const latest = mergeTransferPageForWallet([], latestTransfers, walletPK, "append").map((tx) => mergeTransferDetails(currentById.get(String(tx?.id || "")), tx));
   if (!latest.length) {
     return filterTransfersForWallet(currentTransfers, walletPK);
   }
@@ -25167,7 +25342,7 @@ function pendingReconcileAgeMs(tx, now = Date.now(), firstSeenAt = null) {
   return baseMs ? Math.max(0, now - baseMs) : null;
 }
 function getPendingTransferRetryMs(tx, ageMs, unresolvedCount = 0) {
-  if (isWithdrawalTransfer(tx)) {
+  if (isBitcoinPaymentTransfer(tx)) {
     if (!Number.isFinite(ageMs) || ageMs <= PENDING_TRANSFER_WARM_AGE_MS) {
       return PENDING_TRANSFER_WARM_RETRY_MS;
     }
@@ -27138,206 +27313,6 @@ function createWalletTransferSession({ wallet, walletPK, localCache, claimIncomi
   };
 }
 
-// ../../core/wallet/withdrawops.js
-var P2PKH_DUST_SATS = 546;
-var P2SH_DUST_SATS = 540;
-var P2WPKH_DUST_SATS = 294;
-var SEGWIT_SCRIPT_DUST_SATS = 330;
-function getWithdrawalMinimumReceiveSats(onchainAddress) {
-  const address = cleanText(onchainAddress).toLowerCase();
-  if (address.startsWith("1"))
-    return P2PKH_DUST_SATS;
-  if (address.startsWith("3"))
-    return P2SH_DUST_SATS;
-  const p2wpkhLength = address.startsWith("bcrt1q") ? 44 : 42;
-  if ((address.startsWith("bc1q") || address.startsWith("bcrt1q")) && address.length === p2wpkhLength) {
-    return P2WPKH_DUST_SATS;
-  }
-  return SEGWIT_SCRIPT_DUST_SATS;
-}
-function getWithdrawalReviewAmounts(withdrawal) {
-  const amountSats = toSafeSats(withdrawal?.amountSats);
-  const feeAmountSats = toSafeNonNegativeSats(withdrawal?.feeAmountSats ?? 0, "feeAmountSats");
-  const deductFeeFromWithdrawalAmount = withdrawal?.deductFeeFromWithdrawalAmount !== false;
-  const receiveAmountSats = deductFeeFromWithdrawalAmount ? Math.max(0, amountSats - feeAmountSats) : amountSats;
-  const sendAmountSats = deductFeeFromWithdrawalAmount ? amountSats : amountSats + feeAmountSats;
-  return {
-    sendAmountSats,
-    receiveAmountSats,
-    feeAmountSats
-  };
-}
-function assertWithdrawalReceivesFunds(withdrawal) {
-  const { receiveAmountSats } = getWithdrawalReviewAmounts(withdrawal);
-  const minimumReceiveAmountSats = getWithdrawalMinimumReceiveSats(withdrawal?.onchainAddress);
-  if (receiveAmountSats < minimumReceiveAmountSats) {
-    throw new Error(`withdrawal would create a dust output below ${minimumReceiveAmountSats} sats`);
-  }
-}
-function getWithdrawalReview({ feeQuote, exitSpeed, amountSats, onchainAddress, deductFeeFromWithdrawalAmount = true }) {
-  const safeExitSpeed = getExitSpeed(exitSpeed);
-  const feeQuoteId = feeQuote?.id ?? null;
-  const feeAmountSats = getWithdrawalFeeAmountSats(feeQuote, safeExitSpeed);
-  if (!feeQuoteId || feeAmountSats == null) {
-    throw new Error("withdrawal fee quote unavailable");
-  }
-  const sparkFees = normalizeWithdrawalFeeQuote(feeQuote);
-  const withdrawal = {
-    kind: "cooperative_exit",
-    onchainAddress,
-    amountSats,
-    exitSpeed: safeExitSpeed,
-    deductFeeFromWithdrawalAmount,
-    feeQuote,
-    feeQuoteId,
-    feeAmountSats,
-    fees: {
-      spark: sparkFees
-    },
-    sparkFees,
-    expiresAt: sparkFees?.expiresAt ?? feeQuote.expiresAt ?? null
-  };
-  assertWithdrawalReceivesFunds(withdrawal);
-  return withdrawal;
-}
-async function quoteWithdrawalFees(wallet, network, { onchainAddress, amountSats } = {}) {
-  if (!wallet) {
-    return { success: false, error: new Error("wallet not ready") };
-  }
-  const address = cleanText(onchainAddress);
-  if (!isAddressOnNetwork(address, network)) {
-    return { success: false, error: new Error(`refusing to withdraw - address is not a ${network} address`) };
-  }
-  try {
-    const safeAmountSats = toSafeSats(amountSats);
-    const feeQuote = await wallet.getWithdrawalFeeQuote({
-      amountSats: safeAmountSats,
-      withdrawalAddress: address
-    });
-    if (!feeQuote?.id) {
-      throw new Error("withdrawal fee quote unavailable");
-    }
-    const sparkFees = normalizeWithdrawalFeeQuote(feeQuote);
-    return {
-      success: true,
-      feeQuote,
-      fees: {
-        spark: sparkFees
-      },
-      sparkFees,
-      amountSats: safeAmountSats,
-      onchainAddress: address
-    };
-  } catch (error) {
-    return { success: false, error };
-  }
-}
-async function prepareWithdrawal(wallet, network, { onchainAddress, amountSats, exitSpeed = DEFAULT_EXIT_SPEED, deductFeeFromWithdrawalAmount = true } = {}) {
-  const quoted = await quoteWithdrawalFees(wallet, network, { onchainAddress, amountSats });
-  if (!quoted.success) {
-    return quoted;
-  }
-  try {
-    const withdrawal = getWithdrawalReview({
-      feeQuote: quoted.feeQuote,
-      exitSpeed,
-      amountSats: quoted.amountSats,
-      onchainAddress: quoted.onchainAddress,
-      deductFeeFromWithdrawalAmount
-    });
-    return {
-      success: true,
-      withdrawal,
-      ...withdrawal
-    };
-  } catch (error) {
-    return { success: false, error };
-  }
-}
-async function withdrawFunds(wallet, network, { onchainAddress, amountSats, exitSpeed = DEFAULT_EXIT_SPEED, feeQuote = null, feeQuoteId = null, feeAmountSats = null, deductFeeFromWithdrawalAmount = true } = {}) {
-  if (!wallet) {
-    return { success: false, error: new Error("wallet not ready") };
-  }
-  const address = cleanText(onchainAddress);
-  if (!isAddressOnNetwork(address, network)) {
-    return { success: false, error: new Error(`refusing to withdraw - address is not a ${network} address`) };
-  }
-  try {
-    const safeAmountSats = toSafeSats(amountSats);
-    const safeExitSpeed = getExitSpeed(exitSpeed);
-    let readyFeeQuote = feeQuote;
-    if (!readyFeeQuote && (!feeQuoteId || feeAmountSats == null)) {
-      const quoted = await quoteWithdrawalFees(wallet, network, {
-        onchainAddress: address,
-        amountSats: safeAmountSats
-      });
-      if (!quoted.success) {
-        return quoted;
-      }
-      readyFeeQuote = quoted.feeQuote;
-    }
-    const readyFeeQuoteId = feeQuoteId || readyFeeQuote?.id;
-    const readyFeeAmountSats = feeAmountSats == null ? getWithdrawalFeeAmountSats(readyFeeQuote, safeExitSpeed) : toSafeNonNegativeSats(feeAmountSats, "feeAmountSats");
-    if (!readyFeeQuoteId || readyFeeAmountSats == null) {
-      throw new Error("withdrawal fee quote unavailable");
-    }
-    assertWithdrawalReceivesFunds({
-      onchainAddress: address,
-      amountSats: safeAmountSats,
-      feeAmountSats: readyFeeAmountSats,
-      deductFeeFromWithdrawalAmount
-    });
-    const tx = await wallet.withdraw({
-      onchainAddress: address,
-      amountSats: safeAmountSats,
-      exitSpeed: safeExitSpeed,
-      feeQuoteId: readyFeeQuoteId,
-      feeAmountSats: readyFeeAmountSats,
-      deductFeeFromWithdrawalAmount
-    });
-    return {
-      success: true,
-      tx,
-      feeQuote: readyFeeQuote,
-      fees: readyFeeQuote ? {
-        spark: normalizeWithdrawalFeeQuote(readyFeeQuote)
-      } : null,
-      feeAmountSats: readyFeeAmountSats
-    };
-  } catch (error) {
-    return { success: false, error };
-  }
-}
-async function confirmWithdrawal(wallet, network, withdrawal) {
-  if (!withdrawal) {
-    return { success: false, error: new Error("withdrawal review missing") };
-  }
-  return withdrawFunds(wallet, network, {
-    onchainAddress: withdrawal.onchainAddress,
-    amountSats: withdrawal.amountSats,
-    exitSpeed: withdrawal.exitSpeed,
-    feeQuoteId: withdrawal.feeQuoteId,
-    feeAmountSats: withdrawal.feeAmountSats,
-    deductFeeFromWithdrawalAmount: withdrawal.deductFeeFromWithdrawalAmount
-  });
-}
-
-// ../../core/wallet/withdraw.js
-function createWithdrawal({ wallet, network, updateWalletData }) {
-  const refreshOnSuccess = async (result) => {
-    if (result.success) {
-      await updateWalletData({ reason: "withdraw" });
-    }
-    return result;
-  };
-  return {
-    quoteWithdrawalFees: (params) => quoteWithdrawalFees(wallet, network, params),
-    prepareWithdrawal: (params) => prepareWithdrawal(wallet, network, params),
-    confirmWithdrawal: async (withdrawal) => refreshOnSuccess(await confirmWithdrawal(wallet, network, withdrawal)),
-    withdrawFunds: async (params) => refreshOnSuccess(await withdrawFunds(wallet, network, params))
-  };
-}
-
 // ../../core/wallet/session.js
 var NOOP5 = () => {};
 var ASYNC_NOOP = async () => null;
@@ -27396,18 +27371,12 @@ function createEmptyWalletSessionSnapshot(network, transferSnapshot = null, cach
       requestTransferDiscoveryHotWindow: NOOP5,
       claimDeposits: ASYNC_FALSE,
       getFundingAddress: ASYNC_NOOP,
-      sendMoneyWithSpark: WALLET_NOT_READY,
-      payExternalInvoice: WALLET_NOT_READY,
+      preparePayment: WALLET_NOT_READY,
+      sendPayment: WALLET_NOT_READY,
       createLightningInvoice: WALLET_NOT_READY,
-      quoteLightningFees: WALLET_NOT_READY,
-      sendLightningPayment: WALLET_NOT_READY,
       getLightningReceiveRequest: WALLET_NOT_READY,
       getLightningSendRequest: WALLET_NOT_READY,
-      quoteWithdrawalFees: WALLET_NOT_READY,
-      prepareWithdrawal: WALLET_NOT_READY,
-      confirmWithdrawal: WALLET_NOT_READY,
-      withdrawFunds: WALLET_NOT_READY,
-      runWalletMutation: WALLET_NOT_READY
+      runPayment: WALLET_NOT_READY
     },
     txValue: {
       oldestTxMs: null,
@@ -27538,8 +27507,9 @@ function createWalletSession({
     diag
   });
   const transferState = getTransferState();
-  const send = createWalletSend({
+  const payment = createPayment({
     wallet,
+    walletPK,
     network,
     updateWalletData,
     refreshBalance: balance.getBalance,
@@ -27549,28 +27519,15 @@ function createWalletSession({
     beginSdkActivity: transferState.beginSdkActivity,
     diag
   });
-  const lightning = createLightning({ wallet, updateWalletData });
-  const withdrawal = createWithdrawal({ wallet, network, updateWalletData });
+  const lightning = createLightning({ wallet });
   const privacy = createWalletPrivacy({ wallet, ghostWallet, diag });
   const mutations = createWalletMutationQueue();
-  const sendMoneyWithSpark = (receiverWalletPK, ...args) => {
-    if (sameText(receiverWalletPK, walletPK)) {
-      throw new Error("cannot send money to the same wallet");
-    }
-    return send.sendMoneyWithSpark(receiverWalletPK, ...args);
-  };
   const mutationActions = {
-    sendMoneyWithSpark: (...args) => mutations.run(() => sendMoneyWithSpark(...args)),
-    payExternalInvoice: (...args) => mutations.run(() => send.payExternalInvoice(...args)),
-    sendLightningPayment: (...args) => mutations.run(() => lightning.sendLightningPayment(...args)),
-    confirmWithdrawal: (...args) => mutations.run(() => withdrawal.confirmWithdrawal(...args)),
-    withdrawFunds: (...args) => mutations.run(() => withdrawal.withdrawFunds(...args)),
-    runWalletMutation: (task) => mutations.run(() => task({
-      sendMoneyWithSpark,
-      payExternalInvoice: send.payExternalInvoice,
-      sendLightningPayment: lightning.sendLightningPayment,
-      confirmWithdrawal: withdrawal.confirmWithdrawal,
-      withdrawFunds: withdrawal.withdrawFunds
+    preparePayment: (...args) => mutations.run(() => payment.preparePayment(...args)),
+    sendPayment: (...args) => mutations.run(() => payment.sendPayment(...args)),
+    runPayment: (task) => mutations.run(() => task({
+      preparePayment: payment.preparePayment,
+      sendPayment: payment.sendPayment
     }))
   };
   function buildSnapshot() {
@@ -27592,18 +27549,12 @@ function createWalletSession({
       requestTransferDiscoveryHotWindow: polling.requestTransferDiscoveryHotWindow,
       claimDeposits: claims.claimDeposits,
       getFundingAddress: funding.getFundingAddress,
-      sendMoneyWithSpark: mutationActions.sendMoneyWithSpark,
-      payExternalInvoice: mutationActions.payExternalInvoice,
+      preparePayment: mutationActions.preparePayment,
+      sendPayment: mutationActions.sendPayment,
       createLightningInvoice: lightning.createLightningInvoice,
-      quoteLightningFees: lightning.quoteLightningFees,
-      sendLightningPayment: mutationActions.sendLightningPayment,
       getLightningReceiveRequest: lightning.getLightningReceiveRequest,
       getLightningSendRequest: lightning.getLightningSendRequest,
-      quoteWithdrawalFees: withdrawal.quoteWithdrawalFees,
-      prepareWithdrawal: withdrawal.prepareWithdrawal,
-      confirmWithdrawal: mutationActions.confirmWithdrawal,
-      withdrawFunds: mutationActions.withdrawFunds,
-      runWalletMutation: mutationActions.runWalletMutation
+      runPayment: mutationActions.runPayment
     };
     const txValue = {
       oldestTxMs: currentTransferState.oldestLoadedMs,
@@ -27666,7 +27617,7 @@ function createWalletSession({
       polling.close();
       privacy.close();
       mutations.close();
-      send.close();
+      payment.close();
       claims.close();
       funding.close();
       updateWalletData.close();
@@ -28009,7 +27960,7 @@ function coveredUnitsSince(oldestLoadedMs, unitMs, nowMs2 = Date.now()) {
 }
 var enrichTx = (tx) => {
   const incoming = tx.transferDirection === "INCOMING";
-  const isWithdrawal = isWithdrawalTransfer(tx);
+  const isBitcoinPayment = isBitcoinPaymentTransfer(tx);
   const isFunding = isFundingTransfer(tx);
   const pending = !isCompletedTransfer(tx);
   const peerPK = incoming ? tx.senderIdentityPublicKey : tx.receiverIdentityPublicKey;
@@ -28021,10 +27972,10 @@ var enrichTx = (tx) => {
     totalValue: tx.totalValue,
     amount: incoming ? tx.totalValue : -tx.totalValue,
     funding: isFunding,
-    withdrawal: isWithdrawal,
+    bitcoin: isBitcoinPayment,
     pending,
     pendingCredit: pending && (incoming || isFunding),
-    summaryPending: pending && (incoming || isFunding || isWithdrawal)
+    summaryPending: pending && (incoming || isFunding || isBitcoinPayment)
   };
 };
 var aggregateTxs = (transfers, userPK) => {
@@ -28057,7 +28008,7 @@ var aggregateTxs = (transfers, userPK) => {
     }
     if (!firstDate || txDate < firstDate)
       firstDate = txDate;
-    if (tx.peerPK && tx.peerPK !== userPK && !tx.funding && !tx.withdrawal) {
+    if (tx.peerPK && tx.peerPK !== userPK && !tx.funding && !tx.bitcoin) {
       const txMs = txDate.getTime();
       if (!peerMap.has(tx.peerPK)) {
         peerMap.set(tx.peerPK, {
@@ -28164,7 +28115,9 @@ function txSearchFields(tx) {
     tx?.amount == null ? "" : String(tx.amount),
     tx?.incoming ? "incoming received inflow" : "outgoing sent outflow",
     tx?.funding ? "funded fund deposit" : "",
-    tx?.withdrawal ? "withdrawn withdraw" : "",
+    tx?.bitcoin ? "bitcoin payment onchain on-chain l1" : "",
+    tx?.bitcoinAddress,
+    tx?.bitcoinTxid,
     tx?.pending ? "pending" : "completed"
   ];
 }
@@ -28380,7 +28333,7 @@ function getRecentWalletPeers(transfers, walletPK) {
       continue;
     }
     const tx = enrichTx(raw);
-    if (!isVisibleTransfer(tx) || tx.funding || tx.withdrawal || !tx.peerPK || tx.peerPK === walletPK) {
+    if (!isVisibleTransfer(tx) || tx.funding || tx.bitcoin || !tx.peerPK || tx.peerPK === walletPK) {
       continue;
     }
     const txMs = tx.createdMs || 0;
@@ -28419,7 +28372,7 @@ function getPeerDataFromTransfers(transfers, walletPK, peerPK) {
     if (rawPeerPK !== peerPK)
       continue;
     const tx = enrichTx(raw);
-    if (tx.funding || tx.withdrawal) {
+    if (tx.funding || tx.bitcoin) {
       continue;
     }
     txs.push(tx);