@arkade-os/swap 0.0.1

package/dist/index.cjs

@@ -0,0 +1,3568 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ARKADE_ASSET: () => ARKADE_ASSET,
+  ARKADE_BTC: () => ARKADE_BTC,
+  AddressMismatch: () => AddressMismatch,
+  BTC_ASSET_ID: () => BTC_ASSET_ID,
+  InMemoryAssetSwapRepository: () => InMemoryAssetSwapRepository,
+  IndexedDbAssetSwapRepository: () => IndexedDbAssetSwapRepository,
+  LIGHTNING_BTC: () => LIGHTNING_BTC,
+  LIGHTNING_RECEIVE_PAIR: () => LIGHTNING_RECEIVE_PAIR,
+  LIGHTNING_SEND_PAIR: () => LIGHTNING_SEND_PAIR,
+  LockupAmountMismatchError: () => LockupAmountMismatchError,
+  LockupNeedsRecoveryError: () => LockupNeedsRecoveryError,
+  LockupRegistrationFailed: () => LockupRegistrationFailed,
+  MAX_MIN_CONFIRMATIONS: () => MAX_MIN_CONFIRMATIONS,
+  MIN_CLAIM_WINDOW_SECONDS: () => MIN_CLAIM_WINDOW_SECONDS,
+  MIN_HEADROOM_SECONDS: () => MIN_HEADROOM_SECONDS,
+  OFFER_PACKET_TYPE: () => OFFER_PACKET_TYPE,
+  ONCHAIN_BTC: () => ONCHAIN_BTC,
+  ONCHAIN_CLAIM_MARGIN_SECONDS: () => ONCHAIN_CLAIM_MARGIN_SECONDS,
+  ONCHAIN_DUST_SATS: () => ONCHAIN_DUST_SATS,
+  ONCHAIN_ORDER_MARGIN_SECONDS: () => ONCHAIN_ORDER_MARGIN_SECONDS,
+  ONCHAIN_RECEIVE_PAIR: () => ONCHAIN_RECEIVE_PAIR,
+  ONCHAIN_SECONDS_PER_BLOCK: () => ONCHAIN_SECONDS_PER_BLOCK,
+  ONCHAIN_SEND_PAIR: () => ONCHAIN_SEND_PAIR,
+  QUOTE_OPTIONS: () => QUOTE_OPTIONS,
+  REFUND_MTP_LAG_SECONDS: () => REFUND_MTP_LAG_SECONDS,
+  RFQ_PREIMAGE_TAG: () => RFQ_PREIMAGE_TAG,
+  RFQ_RESOLVED_STATES: () => RFQ_RESOLVED_STATES,
+  RFQ_SWAP_TERMINAL_STATES: () => RFQ_SWAP_TERMINAL_STATES,
+  RFQ_TERMINAL_STATES: () => RFQ_TERMINAL_STATES,
+  RefundNotLocallyPossibleError: () => RefundNotLocallyPossibleError,
+  RfqSwapManager: () => RfqSwapManager,
+  SWAP_LOCKUP_CONTRACT_KIND: () => SWAP_LOCKUP_CONTRACT_KIND,
+  SWAP_LOCKUP_CONTRACT_LABEL: () => SWAP_LOCKUP_CONTRACT_LABEL,
+  SWAP_LOCKUP_CONTRACT_TYPE: () => SWAP_LOCKUP_CONTRACT_TYPE,
+  SwapRefusal: () => SwapRefusal,
+  addAssetSwap: () => addAssetSwap,
+  adoptSwapDescriptor: () => adoptSwapDescriptor,
+  arkadeSwapRequest: () => arkadeSwapRequest,
+  assertFundable: () => assertFundable,
+  assertReceivable: () => assertReceivable,
+  awaitLockupFunding: () => awaitLockupFunding,
+  awaitOnchainFill: () => awaitOnchainFill,
+  awaitRfqResolution: () => awaitRfqResolution,
+  buildHtlcClaim: () => buildHtlcClaim,
+  buildHtlcRefund: () => buildHtlcRefund,
+  buildPreimageMessage: () => buildPreimageMessage,
+  cancelOffer: () => cancelOffer,
+  claimOnchainFill: () => claimOnchainFill,
+  claimReceiveLockup: () => claimReceiveLockup,
+  classifyDepositSpend: () => classifyDepositSpend,
+  classifyOnchainHtlc: () => classifyOnchainHtlc,
+  classifySpend: () => classifySpend,
+  createOffer: () => createOffer,
+  decodeOffer: () => decodeOffer,
+  deriveLightningReceive: () => deriveLightningReceive,
+  deriveOnchainReceive: () => deriveOnchainReceive,
+  deriveOnchainSend: () => deriveOnchainSend,
+  derivePreimage: () => derivePreimage,
+  deriveSwapSecrets: () => deriveSwapSecrets,
+  discoverMarkets: () => discoverMarkets,
+  encodeOffer: () => encodeOffer,
+  extractPreimage: () => extractPreimage,
+  findLockupVtxos: () => findLockupVtxos,
+  findMarket: () => findMarket,
+  getAssetSwaps: () => getAssetSwaps,
+  getAssetSwapsOrThrow: () => getAssetSwapsOrThrow,
+  httpTransport: () => httpTransport,
+  isDeterministicSigner: () => isDeterministicSigner,
+  isRfqSwapTerminal: () => isRfqSwapTerminal,
+  isRfqTerminal: () => isRfqTerminal,
+  lightningReceiveRequest: () => lightningReceiveRequest,
+  lightningSendRequest: () => lightningSendRequest,
+  lightningSendVtxoScript: () => lightningSendVtxoScript,
+  makeCachedFeedFetch: () => makeCachedFeedFetch,
+  newPreimage: () => newPreimage,
+  newRfqId: () => newRfqId,
+  nextOnchainAction: () => nextOnchainAction,
+  offerTermsFromQuote: () => offerTermsFromQuote,
+  offerVtxoScript: () => offerVtxoScript,
+  onchainHtlcScript: () => onchainHtlcScript,
+  onchainReceiveRequest: () => onchainReceiveRequest,
+  onchainSendRequest: () => onchainSendRequest,
+  paymentHashOf: () => paymentHashOf,
+  preimageForRfqSecrets: () => preimageForRfqSecrets,
+  pushClaim: () => pushClaim,
+  pushRefundWithoutReceiver: () => pushRefundWithoutReceiver,
+  randomSwapSecrets: () => randomSwapSecrets,
+  readLockupFate: () => readLockupFate,
+  receiveVtxoScript: () => receiveVtxoScript,
+  refundIfUnresolved: () => refundIfUnresolved,
+  registerLockupContract: () => registerLockupContract,
+  relayTransport: () => relayTransport,
+  requestLightningReceive: () => requestLightningReceive,
+  requestLightningSend: () => requestLightningSend,
+  requestOnchainReceive: () => requestOnchainReceive,
+  requestOnchainSend: () => requestOnchainSend,
+  restoreAssetSwaps: () => restoreAssetSwaps,
+  retireSettledOfferContracts: () => retireSettledOfferContracts,
+  rfqPair: () => rfqPair,
+  rfqSecretsOfRecord: () => rfqSecretsOfRecord,
+  rfqSecretsToRecord: () => rfqSecretsToRecord,
+  sealClaimPacket: () => sealClaimPacket,
+  senderIdentityForRfqSecrets: () => senderIdentityForRfqSecrets,
+  senderIdentityForSwapRecord: () => senderIdentityForSwapRecord,
+  senderPubkeyForRfqSecrets: () => senderPubkeyForRfqSecrets,
+  spendTxidsOf: () => spendTxidsOf,
+  spendUpdate: () => spendUpdate,
+  swapPrograms: () => swapPrograms,
+  unilateralClaimDelay: () => unilateralClaimDelay,
+  unilateralRefundDelay: () => unilateralRefundDelay,
+  unilateralRefundWithoutReceiverDelay: () => unilateralRefundWithoutReceiverDelay,
+  updateAssetSwap: () => updateAssetSwap,
+  updateAssetSwapBestEffort: () => updateAssetSwapBestEffort,
+  validatePlan: () => validatePlan,
+  verifyLockupAddress: () => verifyLockupAddress,
+  verifyReceiveInvoice: () => verifyReceiveInvoice,
+  watchOfferSwaps: () => watchOfferSwaps
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/offer.ts
+var import_base = require("@scure/base");
+var import_utils = require("@scure/btc-signer/utils.js");
+var import_sdk = require("@arkade-os/sdk");
+
+// src/swap-want-asset.program.json
+var swap_want_asset_program_default = {
+  version: 0,
+  name: "banco-btc-to-asset",
+  params: [
+    { name: "makerWP", type: "pubkey" },
+    { name: "wantAmount", type: "int" },
+    { name: "wantAssetTxid", type: "hash" },
+    { name: "wantAssetGroupIndex", type: "int" },
+    { name: "server", type: "pubkey" },
+    { name: "user", type: "pubkey" }
+  ],
+  functions: {
+    fulfill: {
+      tapscript: { signers: ["$server"] },
+      arkadeScript: {
+        asm: [
+          0,
+          "$wantAssetTxid",
+          "$wantAssetGroupIndex",
+          "INSPECTOUTASSETLOOKUP",
+          "VERIFY",
+          "$wantAmount",
+          "GREATERTHANOREQUAL",
+          "VERIFY",
+          0,
+          "INSPECTOUTPUTSCRIPTPUBKEY",
+          1,
+          "EQUALVERIFY",
+          "$makerWP",
+          "EQUAL"
+        ]
+      }
+    },
+    cancel: {
+      tapscript: { signers: ["$user", "$server"] }
+    }
+  }
+};
+
+// src/swap-want-btc.program.json
+var swap_want_btc_program_default = {
+  version: 0,
+  name: "banco-asset-to-btc",
+  params: [
+    { name: "makerWP", type: "pubkey" },
+    { name: "wantAmount", type: "int" },
+    { name: "server", type: "pubkey" },
+    { name: "user", type: "pubkey" }
+  ],
+  functions: {
+    fulfill: {
+      tapscript: { signers: ["$server"] },
+      arkadeScript: {
+        asm: [
+          0,
+          "INSPECTOUTPUTVALUE",
+          "$wantAmount",
+          "GREATERTHANOREQUAL",
+          "VERIFY",
+          0,
+          "INSPECTOUTPUTSCRIPTPUBKEY",
+          1,
+          "EQUALVERIFY",
+          "$makerWP",
+          "EQUAL"
+        ]
+      }
+    },
+    cancel: {
+      tapscript: { signers: ["$user", "$server"] }
+    }
+  }
+};
+
+// src/coverage.ts
+var RETIRABLE = ["fulfilled", "cancelled"];
+var issuedAt = /* @__PURE__ */ new Map();
+var inFlight = /* @__PURE__ */ new Map();
+async function serialize(script, task) {
+  const previous = inFlight.get(script) ?? Promise.resolve();
+  const result = previous.then(task, task);
+  const settled = result.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  inFlight.set(script, settled);
+  void settled.then(() => {
+    if (inFlight.get(script) === settled) inFlight.delete(script);
+  });
+  return result;
+}
+function addressOutstanding(swaps, script) {
+  const issued = issuedAt.get(script);
+  if (issued === void 0) return false;
+  if (swaps.some((s) => s.swapPkScript === script && s.createdAt >= issued)) {
+    issuedAt.delete(script);
+    return false;
+  }
+  return true;
+}
+async function promoteOfferContract(manager, script) {
+  await serialize(script, async () => {
+    await manager.setContractWatchState(script, "watched");
+    issuedAt.set(script, Date.now());
+  });
+}
+async function retireOfferContract(manager, swaps, script) {
+  await serialize(script, async () => {
+    if (swaps.some((s) => s.swapPkScript === script && !RETIRABLE.includes(s.status))) return;
+    if (addressOutstanding(swaps, script)) return;
+    try {
+      await manager.setContractWatchState(script, "retained");
+    } catch (err) {
+      console.warn(`[swap] could not retire offer contract ${script}`, err);
+    }
+  });
+}
+async function retireSettledOfferContracts(manager, swaps) {
+  const settled = new Set(
+    swaps.filter((s) => RETIRABLE.includes(s.status)).map((s) => s.swapPkScript)
+  );
+  for (const script of settled) await retireOfferContract(manager, swaps, script);
+}
+
+// src/store.ts
+var BTC_ASSET_ID = "btc";
+var byNewest = (a, b) => b.createdAt - a.createdAt;
+var getAssetSwapsOrThrow = async (repository) => {
+  return (await repository.getAllSwaps()).filter(
+    (s) => s && typeof s.id === "string" && // offer swaps carry the TLV; onchain-corridor swaps carry
+    // the payment hash instead — either marks a valid record
+    (typeof s.offerHex === "string" || typeof s.paymentHash === "string")
+  ).sort(byNewest);
+};
+var getAssetSwaps = async (repository) => {
+  try {
+    return await getAssetSwapsOrThrow(repository);
+  } catch {
+    return [];
+  }
+};
+var saveSwapOrThrow = async (repository, swap) => {
+  try {
+    await repository.saveSwap(swap);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`failed to save swap ${swap.id}: ${reason}`);
+  }
+};
+var addAssetSwap = async (repository, swap) => {
+  const swaps = await getAssetSwapsOrThrow(repository);
+  if (swaps.some((s) => s.id === swap.id)) return swaps;
+  await saveSwapOrThrow(repository, swap);
+  const at = swaps.findIndex((s) => byNewest(swap, s) <= 0);
+  const merged = [...swaps];
+  merged.splice(at === -1 ? merged.length : at, 0, swap);
+  return merged;
+};
+var updateAssetSwap = async (repository, id, changes) => {
+  const swaps = (await getAssetSwapsOrThrow(repository)).map(
+    (s) => s.id === id ? { ...s, ...changes } : s
+  );
+  const updated = swaps.find((s) => s.id === id);
+  if (updated) await saveSwapOrThrow(repository, updated);
+  return swaps;
+};
+var updateAssetSwapBestEffort = async (repository, id, changes) => {
+  try {
+    return { swaps: await updateAssetSwap(repository, id, changes), persisted: true };
+  } catch (error) {
+    console.warn(`[swap] failed to persist update for swap ${id}`, error);
+    const swaps = (await getAssetSwaps(repository)).map(
+      (s) => s.id === id ? { ...s, ...changes } : s
+    );
+    return { swaps, persisted: false };
+  }
+};
+
+// src/offer.ts
+var swapPrograms = {
+  wantAsset: import_sdk.arkade.parseArtifact(swap_want_asset_program_default),
+  wantBtc: import_sdk.arkade.parseArtifact(swap_want_btc_program_default)
+};
+function swapProgramBinding(offer, serverPubkey) {
+  if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
+    throw new Error("makerPkScript is not a 34-byte taproot scriptPubKey");
+  }
+  return {
+    program: offer.wantAsset ? swapPrograms.wantAsset : swapPrograms.wantBtc,
+    args: {
+      makerWP: offer.makerPkScript.subarray(2),
+      wantAmount: offer.wantAmount,
+      server: serverPubkey,
+      user: offer.makerPublicKey,
+      // internal byte order
+      ...offer.wantAsset && {
+        wantAssetTxid: offer.wantAsset.txid.slice().reverse(),
+        wantAssetGroupIndex: offer.wantAsset.groupIndex
+      }
+    },
+    keys: {
+      serverKey: serverPubkey,
+      userKey: offer.makerPublicKey,
+      emulatorKey: offer.emulatorPubkey
+    }
+  };
+}
+function offerVtxoScript(offer, serverPubkey) {
+  const { program, args, keys } = swapProgramBinding(offer, serverPubkey);
+  return new import_sdk.arkade.ArkadeProgramScript(program, args, keys);
+}
+var OFFER_PACKET_TYPE = 3;
+var FIELDS = {
+  swapPkScript: { tag: 1, width: 34 },
+  wantAmount: { tag: 2, width: 8 },
+  wantAsset: { tag: 3, width: void 0 },
+  makerPkScript: { tag: 5, width: 34 },
+  makerPublicKey: { tag: 7, width: 32 },
+  emulatorPubkey: { tag: 8, width: 32 },
+  offerAsset: { tag: 11, width: void 0 }
+};
+var NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
+var XONLY_LEN = 32;
+var xOnly = (key, label) => {
+  if (key.length === XONLY_LEN) return key;
+  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
+    throw new Error(`${label} is not a compressed or x-only public key`);
+  }
+  return key.slice(1);
+};
+function tlv(type, value) {
+  if (value.length > 65535) throw new Error("TLV value exceeds the u16 length field");
+  return (0, import_utils.concatBytes)(Uint8Array.of(type, value.length >> 8 & 255, value.length & 255), value);
+}
+function encodeOffer(offer) {
+  if (Boolean(offer.wantAsset) === Boolean(offer.offerAsset)) {
+    throw new Error("offer must carry exactly one of wantAsset or offerAsset");
+  }
+  for (const name of [
+    "swapPkScript",
+    "makerPkScript",
+    "makerPublicKey",
+    "emulatorPubkey"
+  ]) {
+    if (offer[name].length !== FIELDS[name].width) {
+      throw new Error(`${name} must be ${FIELDS[name].width} bytes`);
+    }
+  }
+  if (offer.wantAmount < BigInt(0) || offer.wantAmount >> BigInt(64) > BigInt(0)) {
+    throw new Error("wantAmount does not fit the offer wire format (u64)");
+  }
+  const amount = new Uint8Array(FIELDS.wantAmount.width);
+  new DataView(amount.buffer).setBigUint64(0, offer.wantAmount, false);
+  const recs = [
+    tlv(FIELDS.swapPkScript.tag, offer.swapPkScript),
+    tlv(FIELDS.wantAmount.tag, amount)
+  ];
+  if (offer.wantAsset) recs.push(tlv(FIELDS.wantAsset.tag, offer.wantAsset.serialize()));
+  if (offer.offerAsset) recs.push(tlv(FIELDS.offerAsset.tag, offer.offerAsset.serialize()));
+  recs.push(
+    tlv(FIELDS.makerPkScript.tag, offer.makerPkScript),
+    tlv(FIELDS.makerPublicKey.tag, offer.makerPublicKey),
+    tlv(FIELDS.emulatorPubkey.tag, offer.emulatorPubkey)
+  );
+  return (0, import_utils.concatBytes)(...recs);
+}
+function decodeOffer(data) {
+  const fields = {};
+  let off = 0;
+  while (off < data.length) {
+    if (off + 3 > data.length) throw new Error("truncated TLV header");
+    const type = data[off];
+    const length = data[off + 1] << 8 | data[off + 2];
+    off += 3;
+    if (off + length > data.length)
+      throw new Error(`truncated TLV value for type 0x${type.toString(16)}`);
+    const name = NAMES[type];
+    if (!name) throw new Error(`unknown TLV type: 0x${type.toString(16)}`);
+    if (fields[name] !== void 0) throw new Error(`duplicate TLV record: ${name}`);
+    fields[name] = data.slice(off, off + length);
+    off += length;
+  }
+  for (const name of ["wantAsset", "offerAsset"]) {
+    if (fields[name]?.length === 0) throw new Error(`missing/invalid ${name}`);
+  }
+  const need = (name) => {
+    const v = fields[name];
+    const len = FIELDS[name].width;
+    if (!v || len !== void 0 && v.length !== len)
+      throw new Error(`missing/invalid ${name}`);
+    return v;
+  };
+  const amount = need("wantAmount");
+  if (Boolean(fields.wantAsset) === Boolean(fields.offerAsset)) {
+    throw new Error("offer must carry exactly one of wantAsset or offerAsset");
+  }
+  return {
+    swapPkScript: need("swapPkScript"),
+    wantAmount: new DataView(amount.buffer, amount.byteOffset).getBigUint64(0, false),
+    ...fields.wantAsset && { wantAsset: import_sdk.asset.AssetId.fromBytes(fields.wantAsset) },
+    ...fields.offerAsset && { offerAsset: import_sdk.asset.AssetId.fromBytes(fields.offerAsset) },
+    makerPkScript: need("makerPkScript"),
+    makerPublicKey: need("makerPublicKey"),
+    emulatorPubkey: need("emulatorPubkey")
+  };
+}
+var OFFER_CONTRACT_LABEL = "Arkade swap offer";
+var OFFER_CONTRACT_KIND = "asset-swap-offer";
+async function registerOfferContract(wallet, arkServerUrl, network, binding, serverPubkey, expectedPkScript) {
+  const { program, args, keys } = swapProgramBinding(binding, serverPubkey);
+  const contractManager = await wallet.getContractManager();
+  const client = await import_sdk.arkade.Arkade.connect({
+    arkade: new import_sdk.RestArkProvider(arkServerUrl),
+    indexer: new import_sdk.RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    // without this the row's `address` would be derived against the SDK's
+    // default network while its script is right — a row that disagrees with
+    // the address the user is about to fund
+    network: (0, import_sdk.getNetwork)(network),
+    contractManager
+  });
+  const contract = new import_sdk.arkade.ArkadeContract(client, program, args, keys);
+  if (import_base.hex.encode(contract.pkScript) !== import_base.hex.encode(expectedPkScript)) {
+    throw new Error("derived covenant does not match the offer's swapPkScript");
+  }
+  await contract.register({
+    label: OFFER_CONTRACT_LABEL,
+    metadata: { genericallySpendable: false, kind: OFFER_CONTRACT_KIND }
+  });
+  await promoteOfferContract(contractManager, import_base.hex.encode(expectedPkScript));
+}
+async function createOffer(wallet, arkServerUrl, emulatorPubkey, params) {
+  if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
+    throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
+  }
+  const [info, makerAddress, makerPublicKey] = await Promise.all([
+    new import_sdk.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress(),
+    wallet.identity.xOnlyPublicKey()
+  ]);
+  const serverPubKey = xOnly(import_base.hex.decode(info.signerPubkey), "ark signer key");
+  const emuKey = xOnly(emulatorPubkey, "emulator pubkey");
+  const binding = {
+    wantAmount: params.wantAmount,
+    wantAsset: params.wantAsset,
+    offerAsset: params.offerAsset,
+    makerPkScript: import_sdk.ArkAddress.decode(makerAddress).pkScript,
+    makerPublicKey,
+    emulatorPubkey: emuKey
+  };
+  const script = offerVtxoScript(binding, serverPubKey);
+  const offer = { ...binding, swapPkScript: script.pkScript };
+  await registerOfferContract(
+    wallet,
+    arkServerUrl,
+    info.network,
+    binding,
+    serverPubKey,
+    script.pkScript
+  );
+  const payload = encodeOffer(offer);
+  return {
+    offerHex: import_base.hex.encode(payload),
+    extension: { type: OFFER_PACKET_TYPE, payload },
+    // VtxoScript.address owns address construction; assembling an ArkAddress
+    // from tweakedPublicKey here would silently miss any future step it gains
+    address: script.address((0, import_sdk.getNetwork)(info.network).hrp, serverPubKey).encode(),
+    swapPkScript: script.pkScript
+  };
+}
+async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
+  const { repository, fundingTxid, swapAddress } = opts;
+  const offer = decodeOffer(import_base.hex.decode(offerHex));
+  const contractManager = await wallet.getContractManager();
+  const client = await import_sdk.arkade.Arkade.connect({
+    arkade: new import_sdk.RestArkProvider(arkServerUrl),
+    indexer: new import_sdk.RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    // registered offers resolve their VTXOs from the contract repository
+    // instead of a direct indexer query; the indexer above stays as the
+    // fallback for offers created before registration existed
+    contractManager
+    // no `network`, unlike registerOfferContract: the row lookup is by
+    // script and the payout script comes from wallet.getAddress(), so the
+    // client's network (which only shapes address derivation) is unused here
+  });
+  const serverKey = swapAddress ? import_sdk.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, serverKey);
+  const rebuilt = new import_sdk.arkade.ArkadeProgramScript(program, args, keys);
+  if (import_base.hex.encode(rebuilt.pkScript) !== import_base.hex.encode(offer.swapPkScript)) {
+    throw new Error(
+      "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
+    );
+  }
+  const contract = new import_sdk.arkade.ArkadeContract(client, program, args, keys);
+  const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
+  if (!fundingTxid && vtxos.length > 1) {
+    throw new Error(
+      "multiple spendable deposits at the swap address \u2014 pass fundingTxid to select one"
+    );
+  }
+  const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
+  if (!vtxo) throw new Error("no spendable VTXO at the swap address");
+  const makerPkScript = import_sdk.ArkAddress.decode(makerAddress).pkScript;
+  const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
+  for (const a of vtxo.assets ?? []) {
+    cancel.withAsset({
+      assetId: a.assetId,
+      inputs: [{ vin: 0, amount: BigInt(a.amount) }],
+      outputs: [{ vout: 0, amount: BigInt(a.amount) }]
+    });
+  }
+  const swapId = fundingTxid ?? vtxo.txid;
+  const hasLocalRecord = (await getAssetSwapsOrThrow(repository)).some((s) => s.id === swapId);
+  if (hasLocalRecord) await updateAssetSwap(repository, swapId, { status: "cancelling" });
+  const { txid } = await cancel.send();
+  if (hasLocalRecord) {
+    const { persisted, swaps } = await updateAssetSwapBestEffort(repository, swapId, {
+      status: "cancelled",
+      spentTxid: txid
+    });
+    if (persisted) {
+      await retireOfferContract(contractManager, swaps, import_base.hex.encode(offer.swapPkScript));
+    }
+  }
+  return txid;
+}
+
+// src/markets.ts
+var import_solver_discovery = require("@arkade-os/solver-discovery");
+var import_sdk2 = require("@arkade-os/sdk");
+var QUOTE_OPTIONS = { safetyBps: 0 };
+var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  return async (input, init) => {
+    const url = input instanceof Request ? input.url : String(input);
+    const hit = cache.get(url);
+    if (hit) {
+      if (Date.now() - hit.at < ttlMs) return new Response(hit.body);
+      cache.delete(url);
+    }
+    const pending = inflight.get(url);
+    if (pending) {
+      const body = await pending;
+      if (body !== void 0) return new Response(body);
+    }
+    let settle = () => {
+    };
+    inflight.set(
+      url,
+      new Promise((resolve) => {
+        settle = resolve;
+      })
+    );
+    try {
+      const response = await fetchImpl(input, init);
+      let body;
+      if (response.ok) {
+        try {
+          body = await response.clone().text();
+          cache.set(url, { at: Date.now(), body });
+        } catch {
+          body = void 0;
+        }
+      }
+      settle(body);
+      return response;
+    } catch (err) {
+      settle(void 0);
+      throw err;
+    } finally {
+      inflight.delete(url);
+    }
+  };
+};
+var MARKETS_CACHE_TTL_MS = 60 * 60 * 1e3;
+var isMarketShaped = (m) => {
+  const market = m;
+  return typeof market?.pair === "string" && typeof market.base_asset?.id === "string" && typeof market.quote_asset?.id === "string" && typeof market.quote_asset.decimals === "number";
+};
+var readMarketsCache = async (repository, network, registry) => {
+  try {
+    const entry = await repository.getCachedMarkets(network, registry);
+    if (!Array.isArray(entry?.markets) || typeof entry?.fetchedAt !== "number")
+      return void 0;
+    return entry.markets.every(isMarketShaped) ? entry : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var discoverMarkets = async (options) => {
+  const {
+    network,
+    registryUrl: registry,
+    repository,
+    localCards = [],
+    logger,
+    fetchImpl,
+    useCache = true
+  } = options;
+  if (!registry || !(0, import_solver_discovery.isNetwork)(network)) return [];
+  const cached = repository && await readMarketsCache(repository, network, registry);
+  if (useCache && cached && Date.now() - cached.fetchedAt < MARKETS_CACHE_TTL_MS)
+    return cached.markets;
+  const { markets, sources, warnings } = await (0, import_solver_discovery.discover)({
+    registries: [registry],
+    localCards,
+    network,
+    fetchImpl
+  });
+  if (warnings.length) logger?.("solver discovery:", ...warnings);
+  const reachable = sources.some((source) => source.ok);
+  if (!reachable && cached) return cached.markets;
+  if (reachable && repository) {
+    try {
+      await repository.saveCachedMarkets(network, registry, {
+        markets,
+        fetchedAt: Date.now()
+      });
+    } catch {
+    }
+  }
+  return markets;
+};
+var findMarket = (markets, fromId, toId) => {
+  if (fromId === toId) return void 0;
+  const givingBase = (0, import_solver_discovery.bestMarket)(markets, { baseId: fromId, quoteId: toId, wantSide: "quote" });
+  if (givingBase) return { market: givingBase, give: "base" };
+  return {
+    market: (0, import_solver_discovery.bestMarket)(markets, { baseId: toId, quoteId: fromId, wantSide: "base" }),
+    give: "quote"
+  };
+};
+var validatePlan = (plan, giveBalance, dust) => {
+  if (plan.deposit.atomic > giveBalance) return "insufficient-balance";
+  const { min, max, withinLimits } = plan.limits;
+  if (!min || !max) return "side-disabled";
+  const giveLimits = (0, import_solver_discovery.sideLimits)(plan.market, plan.give);
+  if (!giveLimits) return "side-disabled";
+  if (plan.deposit.atomic < giveLimits.min) return "below-min";
+  if (plan.deposit.atomic > giveLimits.max) return "above-max";
+  if (!withinLimits) return plan.receive.atomic < min.atomic ? "below-min" : "above-max";
+  const depositIsBtc = plan.deposit.asset.id === BTC_ASSET_ID;
+  const receiveIsBtc = plan.receive.asset.id === BTC_ASSET_ID;
+  if (depositIsBtc || receiveIsBtc) {
+    const btcSide = depositIsBtc ? plan.deposit.atomic : plan.receive.atomic;
+    if ((0, import_sdk2.isSubdust)(btcSide, dust)) return "below-dust";
+  }
+  return void 0;
+};
+
+// src/repository.ts
+var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
+var InMemoryAssetSwapRepository = class {
+  version = 1;
+  swaps = /* @__PURE__ */ new Map();
+  scanned = /* @__PURE__ */ new Set();
+  markets = /* @__PURE__ */ new Map();
+  async saveSwap(swap) {
+    this.swaps.set(swap.id, swap);
+  }
+  async getAllSwaps() {
+    return [...this.swaps.values()];
+  }
+  async getScannedTxids() {
+    return new Set(this.scanned);
+  }
+  async markTxidsScanned(txids) {
+    for (const txid of txids) this.scanned.add(txid);
+  }
+  async getCachedMarkets(network, registry) {
+    return this.markets.get(marketsCacheKey(network, registry));
+  }
+  async saveCachedMarkets(network, registry, entry) {
+    this.markets.set(marketsCacheKey(network, registry), entry);
+  }
+  async clear() {
+    this.swaps.clear();
+    this.scanned.clear();
+    this.markets.clear();
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+
+// src/indexedDbRepository.ts
+var import_sdk3 = require("@arkade-os/sdk");
+var DEFAULT_DB_NAME = "arkade-intents";
+var DB_VERSION = 1;
+var STORE_SWAPS = "swaps";
+var STORE_SCANNED = "scannedTxids";
+var STORE_MARKETS = "markets";
+var STORES = [
+  [STORE_SWAPS, { keyPath: "id" }],
+  [STORE_SCANNED],
+  [STORE_MARKETS]
+];
+function initDatabase(db) {
+  for (const [name, options] of STORES) {
+    if (!db.objectStoreNames.contains(name)) db.createObjectStore(name, options);
+  }
+}
+var request = (req) => new Promise((resolve, reject) => {
+  req.onsuccess = () => resolve(req.result);
+  req.onerror = () => reject(req.error);
+});
+var txDone = (tx) => new Promise((resolve, reject) => {
+  tx.oncomplete = () => resolve();
+  tx.onerror = () => reject(tx.error);
+  tx.onabort = () => reject(tx.error);
+});
+var IndexedDbAssetSwapRepository = class {
+  constructor(dbName = DEFAULT_DB_NAME) {
+    this.dbName = dbName;
+  }
+  dbName;
+  version = 1;
+  // the promise, not the resolved database: openDatabase bumps a refcount on
+  // every call including cache hits, while dispose closes once, so two
+  // concurrent first calls would strand the refcount above zero and leak the
+  // connection for the process lifetime. Cleared on failure so a failed open
+  // can be retried rather than cached forever.
+  dbPromise = null;
+  ensureDb() {
+    return this.dbPromise ??= (0, import_sdk3.openDatabase)(this.dbName, DB_VERSION, initDatabase).catch(
+      (err) => {
+        this.dbPromise = null;
+        throw err;
+      }
+    );
+  }
+  async readStore(name) {
+    return (await this.ensureDb()).transaction([name], "readonly").objectStore(name);
+  }
+  /** Every write in one place, so none of them can forget to await the
+   * commit. Requests need no individual await: a failed one aborts the
+   * transaction, which `txDone` reports. */
+  async write(name, apply) {
+    const tx = (await this.ensureDb()).transaction([name], "readwrite");
+    const done = txDone(tx);
+    apply(tx.objectStore(name));
+    await done;
+  }
+  async saveSwap(swap) {
+    await this.write(STORE_SWAPS, (store) => {
+      store.put(swap);
+    });
+  }
+  async getAllSwaps() {
+    return request((await this.readStore(STORE_SWAPS)).getAll());
+  }
+  async getScannedTxids() {
+    const keys = await request((await this.readStore(STORE_SCANNED)).getAllKeys());
+    return new Set(keys);
+  }
+  async markTxidsScanned(txids) {
+    await this.write(STORE_SCANNED, (store) => {
+      for (const txid of txids) store.put(txid, txid);
+    });
+  }
+  async getCachedMarkets(network, registry) {
+    const store = await this.readStore(STORE_MARKETS);
+    return request(store.get(marketsCacheKey(network, registry)));
+  }
+  async saveCachedMarkets(network, registry, entry) {
+    await this.write(STORE_MARKETS, (store) => {
+      store.put(entry, marketsCacheKey(network, registry));
+    });
+  }
+  /** All stores in one transaction: clearing swaps but keeping scanned txids
+   * would leave the restore scan permanently skipping those funding txs, so
+   * a partial clear must not be observable. */
+  async clear() {
+    const stores = STORES.map(([name]) => name);
+    const tx = (await this.ensureDb()).transaction(stores, "readwrite");
+    const done = txDone(tx);
+    for (const name of stores) tx.objectStore(name).clear();
+    await done;
+  }
+  async [Symbol.asyncDispose]() {
+    if (!this.dbPromise) return;
+    await (0, import_sdk3.closeDatabase)(this.dbName);
+    this.dbPromise = null;
+  }
+};
+
+// src/restore.ts
+var import_base2 = require("@scure/base");
+var import_sdk4 = require("@arkade-os/sdk");
+var TXS_PER_REQUEST = 50;
+async function fetchParsedTxs(indexer, txids) {
+  const parsedByTxid = /* @__PURE__ */ new Map();
+  if (txids.length === 0) return parsedByTxid;
+  const chunks = [];
+  for (let i = 0; i < txids.length; i += TXS_PER_REQUEST) {
+    chunks.push(txids.slice(i, i + TXS_PER_REQUEST));
+  }
+  const chunkResults = await Promise.allSettled(
+    chunks.map(async (ids) => (await indexer.getVirtualTxs(ids)).txs)
+  );
+  for (const result of chunkResults) {
+    if (result.status !== "fulfilled") continue;
+    for (const psbt of result.value) {
+      try {
+        const parsed = import_sdk4.Transaction.fromPSBT(import_base2.base64.decode(psbt));
+        parsedByTxid.set(parsed.id, parsed);
+      } catch {
+      }
+    }
+  }
+  return parsedByTxid;
+}
+var unscannedSwapCandidates = (txs, existingIds, scanned) => txs.filter(
+  (tx) => tx.type === "sent" && tx.redeemTxid && !existingIds.has(tx.redeemTxid) && !scanned.has(tx.redeemTxid)
+);
+function classifySpend(offer, serverPubkey, spendTx, deposit) {
+  let leaves;
+  try {
+    const script = offerVtxoScript(offer, serverPubkey);
+    if (import_base2.hex.encode(script.pkScript) !== import_base2.hex.encode(offer.swapPkScript)) return "indeterminate";
+    leaves = {
+      cancel: script.functionByName("cancel")?.leafScript,
+      fulfill: script.functionByName("fulfill")?.leafScript
+    };
+  } catch {
+    return "indeterminate";
+  }
+  for (let i = 0; i < spendTx.inputsLength; i++) {
+    const input = spendTx.getInput(i);
+    if (!input.txid || input.index !== deposit.vout) continue;
+    if (import_base2.hex.encode(input.txid) !== deposit.txid) continue;
+    for (const leaf of input.tapLeafScript ?? []) {
+      const spent = import_base2.hex.encode((0, import_sdk4.scriptFromTapLeafScript)(leaf));
+      if (leaves.cancel && spent === import_base2.hex.encode(leaves.cancel)) return "cancelled";
+      if (leaves.fulfill && spent === import_base2.hex.encode(leaves.fulfill)) return "fulfilled";
+    }
+  }
+  return "indeterminate";
+}
+var spendTxidsOf = (vtxo) => [vtxo.spentBy, vtxo.arkTxId].filter((id) => Boolean(id));
+function classifyDepositSpend(offer, serverPubkey, spendTxs, deposit) {
+  for (const tx of spendTxs) {
+    const kind = classifySpend(offer, serverPubkey, tx, deposit);
+    if (kind !== "indeterminate") return kind;
+  }
+  return "indeterminate";
+}
+async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
+  const { serverPubkey, scanned = /* @__PURE__ */ new Set() } = opts;
+  const candidates = unscannedSwapCandidates(txs, existingIds, scanned);
+  if (candidates.length === 0) return { restored: [], scannedTxids: [] };
+  const byTxid = new Map(candidates.map((tx) => [tx.redeemTxid, tx]));
+  const parsedByTxid = await fetchParsedTxs(
+    indexer,
+    candidates.map((tx) => tx.redeemTxid)
+  );
+  const fetchedTxids = [];
+  const found = [];
+  for (const [txid, parsed] of parsedByTxid) {
+    const fundingTx = byTxid.get(txid);
+    if (!fundingTx) continue;
+    fetchedTxids.push(txid);
+    try {
+      const packet = import_sdk4.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
+      if (!packet) continue;
+      const payload = packet.serialize();
+      found.push({
+        fundingTx,
+        offer: decodeOffer(payload),
+        offerHex: import_base2.hex.encode(payload)
+      });
+    } catch {
+    }
+  }
+  if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
+  const scripts = [...new Set(found.map((f) => import_base2.hex.encode(f.offer.swapPkScript)))];
+  const { vtxos } = await indexer.getVtxos({ scripts });
+  const vtxoByScriptAndTxid = new Map(vtxos.map((v) => [`${v.script}:${v.txid}`, v]));
+  const txByAnyId = /* @__PURE__ */ new Map();
+  for (const tx of txs) {
+    for (const id of [tx.boardingTxid, tx.redeemTxid, tx.roundTxid]) {
+      if (id) txByAnyId.set(id, tx);
+    }
+  }
+  const spendTxids = /* @__PURE__ */ new Set();
+  for (const { fundingTx, offer } of found) {
+    const vtxo = vtxoByScriptAndTxid.get(
+      `${import_base2.hex.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
+    );
+    if (vtxo?.virtualStatus.state !== "spent") continue;
+    for (const txid of spendTxidsOf(vtxo)) spendTxids.add(txid);
+  }
+  const spendTxByTxid = await fetchParsedTxs(indexer, [...spendTxids]);
+  const restored = [];
+  const unresolved = /* @__PURE__ */ new Set();
+  for (const { fundingTx, offer, offerHex } of found) {
+    const swapPkScript = import_base2.hex.encode(offer.swapPkScript);
+    const vtxo = vtxoByScriptAndTxid.get(`${swapPkScript}:${fundingTx.redeemTxid}`);
+    if (!vtxo) {
+      unresolved.add(fundingTx.redeemTxid);
+      continue;
+    }
+    const depositRider = vtxo.assets?.length === 1 && vtxo.assets[0].amount > BigInt(0) ? vtxo.assets[0] : void 0;
+    const fromAsset = offer.offerAsset?.toString() ?? depositRider?.assetId ?? BTC_ASSET_ID;
+    const toAsset = offer.wantAsset?.toString() ?? BTC_ASSET_ID;
+    const depositAmount = fromAsset === BTC_ASSET_ID ? BigInt(vtxo.value) : vtxo.assets?.find((a) => a.assetId === fromAsset)?.amount;
+    if (depositAmount === void 0) {
+      unresolved.add(fundingTx.redeemTxid);
+      continue;
+    }
+    const fromAmount = depositAmount.toString();
+    const state = vtxo.virtualStatus.state;
+    const spentTxid = state === "spent" ? vtxo.arkTxId || vtxo.spentBy : void 0;
+    let status = "pending";
+    if (state === "swept") status = "recoverable";
+    else if (state === "spent") {
+      const spendTxs = spendTxidsOf(vtxo).map((id) => spendTxByTxid.get(id)).filter((tx) => tx !== void 0);
+      const kind = classifyDepositSpend(offer, serverPubkey, spendTxs, {
+        txid: vtxo.txid,
+        vout: vtxo.vout
+      });
+      if (kind === "indeterminate") {
+        unresolved.add(fundingTx.redeemTxid);
+        continue;
+      }
+      status = kind;
+    }
+    restored.push({
+      id: fundingTx.redeemTxid,
+      fromAsset,
+      toAsset,
+      fromAmount,
+      toAmount: offer.wantAmount.toString(),
+      // ponytail(arkade-os/ts-sdk#680): empty address makes cancel fall back
+      // to the current server key; store the funded address if server-key
+      // rotations become real (cancelOffer now at least diagnoses the
+      // mismatch instead of reporting a missing VTXO)
+      swapAddress: "",
+      swapPkScript,
+      offerHex,
+      fundingTxid: fundingTx.redeemTxid,
+      spentTxid,
+      status,
+      createdAt: fundingTx.createdAt ? fundingTx.createdAt * 1e3 : vtxo.createdAt.getTime(),
+      // the completion time is the caller's record of the spend, if it
+      // has one — the psbt that classified it carries no timestamp
+      ...status === "fulfilled" && spentTxid && txByAnyId.get(spentTxid)?.createdAt ? { completedAt: txByAnyId.get(spentTxid).createdAt * 1e3 } : {}
+    });
+  }
+  return { restored, scannedTxids: fetchedTxids.filter((id) => !unresolved.has(id)) };
+}
+
+// src/watch.ts
+var import_base3 = require("@scure/base");
+var import_sdk5 = require("@arkade-os/sdk");
+var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
+function spendUpdate(swap, spend) {
+  if (TERMINAL.includes(swap.status)) return void 0;
+  if (spend.kind === "indeterminate") return void 0;
+  const status = spend.kind === "cancelled" ? "cancelled" : "fulfilled";
+  return {
+    status,
+    spentTxid: spend.txid,
+    // mirrors restore.ts: a completion time is a fill's, not a cancel's
+    ...status === "fulfilled" && spend.at ? { completedAt: spend.at } : {}
+  };
+}
+async function watchOfferSwaps({
+  wallet,
+  arkServerUrl,
+  repository,
+  onUpdate
+}) {
+  const manager = await wallet.getContractManager();
+  const serverPubkey = import_sdk5.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
+  const indexer = new import_sdk5.RestIndexerProvider(arkServerUrl);
+  let queue = Promise.resolve();
+  const enqueue = (task) => {
+    queue = queue.then(task).catch(() => {
+    });
+  };
+  const classify = async (swap, vtxo, spentTxid) => {
+    if (swap.spentTxid === spentTxid && swap.status === "cancelling") return "cancelled";
+    try {
+      const candidates = spendTxidsOf(vtxo);
+      if (candidates.length === 0) return "indeterminate";
+      const { txs } = await indexer.getVirtualTxs(candidates);
+      return classifyDepositSpend(
+        decodeOffer(import_base3.hex.decode(swap.offerHex)),
+        serverPubkey,
+        txs.map((psbt) => import_sdk5.Transaction.fromPSBT(import_base3.base64.decode(psbt))),
+        { txid: vtxo.txid, vout: vtxo.vout }
+      );
+    } catch {
+      return "indeterminate";
+    }
+  };
+  const handleSpend = async (event) => {
+    if (event.contract.metadata?.kind !== OFFER_CONTRACT_KIND) return;
+    for (const vtxo of event.vtxos) {
+      const spentTxid = vtxo.arkTxId || vtxo.spentBy;
+      if (!spentTxid) continue;
+      const swap = (await getAssetSwaps(repository)).find(
+        (s) => s.fundingTxid === vtxo.txid && s.swapPkScript === event.contractScript
+      );
+      if (!swap) continue;
+      const kind = await classify(swap, vtxo, spentTxid);
+      const changes = spendUpdate(swap, { txid: spentTxid, kind, at: event.timestamp });
+      if (!changes) continue;
+      const { persisted, swaps } = await updateAssetSwapBestEffort(
+        repository,
+        swap.id,
+        changes
+      );
+      if (!persisted) continue;
+      onUpdate?.({ ...swap, ...changes });
+      if (changes.status && RETIRABLE.includes(changes.status)) {
+        await retireOfferContract(manager, swaps, event.contractScript);
+      }
+    }
+  };
+  const unsubscribe = manager.onContractEvent((event) => {
+    if (event.type !== "vtxo_spent") return;
+    enqueue(() => handleSpend(event));
+  });
+  return {
+    stop: unsubscribe,
+    idle: () => queue
+  };
+}
+
+// src/rfq.ts
+var import_base8 = require("@scure/base");
+var import_legacy2 = require("@noble/hashes/legacy.js");
+var import_sdk8 = require("@arkade-os/sdk");
+
+// src/onchainHtlc.ts
+var import_base4 = require("@scure/base");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_legacy = require("@noble/hashes/legacy.js");
+var btc = __toESM(require("@scure/btc-signer"), 1);
+var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
+var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
+var MAX_MIN_CONFIRMATIONS = 6;
+var ONCHAIN_SECONDS_PER_BLOCK = 600;
+var ONCHAIN_DUST_SATS = BigInt(330);
+var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
+var paymentHashOf = (preimage) => import_base4.hex.encode((0, import_sha2.sha256)(preimage));
+var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base4.hex.decode(paymentHash));
+var L1_NETWORKS = {
+  bitcoin: btc.NETWORK,
+  testnet: btc.TEST_NETWORK,
+  regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
+};
+function onchainHtlcScript(params, network) {
+  if (params.claimKey.length !== 32 || params.refundKey.length !== 32) {
+    throw new Error("claimKey and refundKey must be 32-byte x-only keys");
+  }
+  if (!Number.isInteger(params.refundLocktime) || params.refundLocktime <= 0) {
+    throw new Error(
+      `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
+    );
+  }
+  const h160 = h160FromPaymentHash(params.paymentHash);
+  const claim = btc.Script.encode([
+    "SIZE",
+    32,
+    "EQUALVERIFY",
+    "HASH160",
+    h160,
+    "EQUALVERIFY",
+    params.claimKey,
+    "CHECKSIG"
+  ]);
+  const refund = btc.Script.encode([
+    btc.ScriptNum().encode(BigInt(params.refundLocktime)),
+    "CHECKLOCKTIMEVERIFY",
+    "DROP",
+    params.refundKey,
+    "CHECKSIG"
+  ]);
+  const payment = btc.p2tr(
+    btc.TAPROOT_UNSPENDABLE_KEY,
+    btc.taprootListToTree([{ script: claim }, { script: refund }]),
+    L1_NETWORKS[network],
+    true
+  );
+  const controlBlockFor = (leaf) => {
+    for (const [block, script] of payment.tapLeafScript ?? []) {
+      if (script.length - 1 === leaf.length && import_base4.hex.encode(script.subarray(0, leaf.length)) === import_base4.hex.encode(leaf)) {
+        return btc.TaprootControlBlock.encode(block);
+      }
+    }
+    throw new Error("leaf missing from compiled taproot tree");
+  };
+  return {
+    address: payment.address,
+    pkScript: payment.script,
+    leaves: { claim, refund },
+    controlBlocks: { claim: controlBlockFor(claim), refund: controlBlockFor(refund) },
+    paymentHash: params.paymentHash,
+    refundLocktime: params.refundLocktime
+  };
+}
+var buildLeafSpend = async (input) => {
+  if (!Number.isFinite(input.feeRateSatVb) || input.feeRateSatVb <= 0) {
+    throw new Error(`feeRateSatVb must be positive, got ${input.feeRateSatVb}`);
+  }
+  const assemble = (payout2) => {
+    const tx2 = new btc.Transaction({ lockTime: input.lockTime ?? 0 });
+    tx2.addInput({
+      txid: input.utxo.txid,
+      index: input.utxo.vout,
+      witnessUtxo: { script: input.htlc.pkScript, amount: input.utxo.amount },
+      sequence: input.sequence
+    });
+    tx2.addOutput({ script: input.payoutPkScript, amount: payout2 });
+    return tx2;
+  };
+  const witness = (sig2) => [
+    sig2,
+    ...input.stackAboveSig,
+    input.leaf,
+    input.controlBlock
+  ];
+  const sizing = assemble(input.utxo.amount);
+  sizing.updateInput(0, { finalScriptWitness: witness(new Uint8Array(64)) }, true);
+  const fee = BigInt(Math.ceil(sizing.vsize * input.feeRateSatVb));
+  const payout = input.utxo.amount - fee;
+  if (payout < ONCHAIN_DUST_SATS) {
+    throw new Error(
+      `fee ${fee} leaves ${payout} sats from a ${input.utxo.amount} sat HTLC \u2014 below the ${ONCHAIN_DUST_SATS} sat dust limit`
+    );
+  }
+  const tx = assemble(payout);
+  const sighash = tx.preimageWitnessV1(
+    0,
+    [input.htlc.pkScript],
+    btc.SigHash.DEFAULT,
+    [input.utxo.amount],
+    void 0,
+    input.leaf,
+    192
+  );
+  const sig = await input.sign(sighash);
+  if (sig.length !== 64)
+    throw new Error(`sign() must return a 64-byte BIP340 signature, got ${sig.length}`);
+  tx.updateInput(0, { finalScriptWitness: witness(sig) }, true);
+  return { txHex: tx.hex, txid: tx.id, payoutAmount: payout };
+};
+var buildHtlcClaim = async (input) => {
+  if (paymentHashOf(input.preimage) !== input.htlc.paymentHash) {
+    throw new Error("preimage does not hash to the HTLC's payment hash");
+  }
+  return buildLeafSpend({
+    htlc: input.htlc,
+    utxo: input.utxo,
+    leaf: input.htlc.leaves.claim,
+    controlBlock: input.htlc.controlBlocks.claim,
+    stackAboveSig: [input.preimage],
+    payoutPkScript: input.payoutPkScript,
+    feeRateSatVb: input.feeRateSatVb,
+    sign: input.sign,
+    sequence: 4294967293
+  });
+};
+var buildHtlcRefund = (input) => buildLeafSpend({
+  htlc: input.htlc,
+  utxo: input.utxo,
+  leaf: input.htlc.leaves.refund,
+  controlBlock: input.htlc.controlBlocks.refund,
+  stackAboveSig: [],
+  payoutPkScript: input.payoutPkScript,
+  feeRateSatVb: input.feeRateSatVb,
+  sign: input.sign,
+  lockTime: input.htlc.refundLocktime,
+  // any value below 0xffffffff enables nLockTime enforcement
+  sequence: 4294967294
+});
+function extractPreimage(txHex, paymentHash) {
+  let raw;
+  try {
+    raw = btc.RawTx.decode(import_base4.hex.decode(txHex));
+  } catch {
+    return null;
+  }
+  for (const stack of raw.witnesses ?? []) {
+    for (const item of stack) {
+      if (item.length === 32 && import_base4.hex.encode((0, import_sha2.sha256)(item)) === paymentHash) return item;
+    }
+  }
+  return null;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function awaitOnchainFill(chain, htlc, minConfirmations, options = {}) {
+  const pollMs = options.pollMs ?? 5e3;
+  for (; ; ) {
+    const utxos = await chain.getScriptUtxos(htlc.pkScript);
+    const eligible = utxos.filter((u) => u.confirmations >= minConfirmations).sort((a, b) => b.amount > a.amount ? 1 : -1);
+    if (eligible[0]) return eligible[0];
+    if (options.deadline !== void 0 && Date.now() / 1e3 >= options.deadline) {
+      const error = new Error("HTLC was not filled before the deadline");
+      error.reason = "fill_timeout";
+      throw error;
+    }
+    await sleep(pollMs);
+  }
+}
+async function claimOnchainFill(chain, input) {
+  const now = input.now ?? Math.floor(Date.now() / 1e3);
+  if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
+    const error = new Error(
+      "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
+    );
+    error.reason = "claim_window_closed";
+    throw error;
+  }
+  const spend = await buildHtlcClaim(input);
+  const txid = await chain.broadcast(spend.txHex);
+  return { txid, payoutAmount: spend.payoutAmount };
+}
+async function classifyOnchainHtlc(chain, input) {
+  const utxos = await chain.getScriptUtxos(input.htlc.pkScript);
+  const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
+  if (!best) {
+    if (!input.funding) return { phase: "unfunded" };
+    const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
+    if (!spend) return { phase: "unfunded" };
+    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
+    const txid = btc.Transaction.fromRaw(import_base4.hex.decode(spend.txHex), {
+      allowUnknownInputs: true,
+      allowUnknownOutputs: true
+    }).id;
+    return preimage ? { phase: "claimed", txid, preimage } : { phase: "swept", txid };
+  }
+  if (best.confirmations < input.minConfirmations)
+    return { phase: "awaiting_confirmations", utxo: best };
+  const mtp = await chain.getMtp();
+  if (mtp >= input.htlc.refundLocktime) return { phase: "refundable", utxo: best };
+  return { phase: "claimable", utxo: best };
+}
+
+// src/secrets.ts
+var import_base5 = require("@scure/base");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_utils2 = require("@noble/hashes/utils.js");
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_sdk6 = require("@arkade-os/sdk");
+var RFQ_PREIMAGE_TAG = "Arkade-RFQ-Preimage-v1";
+function buildPreimageMessage(xonly, index) {
+  if (xonly.length !== 32) {
+    throw new Error(`x-only pubkey must be 32 bytes, got ${xonly.length}`);
+  }
+  if (!Number.isInteger(index) || index < 0 || index > 4294967295) {
+    throw new Error(`index must be a u32, got ${index}`);
+  }
+  const tag = new TextEncoder().encode(RFQ_PREIMAGE_TAG);
+  const message = new Uint8Array(tag.length + 32 + 4);
+  message.set(tag, 0);
+  message.set(xonly, tag.length);
+  new DataView(message.buffer).setUint32(tag.length + 32, index, true);
+  return message;
+}
+var PREIMAGE_INDEX = 0;
+async function deriveSwapSecrets(wallet) {
+  if (!(0, import_sdk6.isHDAllocationCapable)(wallet)) return void 0;
+  const signingDescriptor = await wallet.getNextSigningDescriptor();
+  if (!signingDescriptor) return void 0;
+  return { derivable: true, signingDescriptor };
+}
+function randomSwapSecrets(opts = {}) {
+  if (opts.preimage instanceof Uint8Array && opts.preimage.length !== 32) {
+    throw new Error(`preimage must be 32 bytes, got ${opts.preimage.length}`);
+  }
+  const preimage = opts.preimage instanceof Uint8Array ? opts.preimage : opts.preimage ? (0, import_utils2.randomBytes)(32) : void 0;
+  return {
+    derivable: false,
+    senderPrivateKey: import_secp256k1.schnorr.utils.randomSecretKey(),
+    ...preimage ? { preimage } : {}
+  };
+}
+function rfqSecretsToRecord(secrets) {
+  if (secrets.derivable) {
+    return {
+      signingDescriptor: secrets.signingDescriptor,
+      ...secrets.preimage ? { preimageHex: import_base5.hex.encode(secrets.preimage) } : {}
+    };
+  }
+  return {
+    fallbackSecrets: {
+      version: 1,
+      type: "stored",
+      senderPrivateKeyHex: import_base5.hex.encode(secrets.senderPrivateKey),
+      ...secrets.preimage ? { preimageHex: import_base5.hex.encode(secrets.preimage) } : {}
+    }
+  };
+}
+function rfqSecretsOfRecord(record) {
+  if (record.signingDescriptor) {
+    return {
+      derivable: true,
+      signingDescriptor: record.signingDescriptor,
+      ...record.preimageHex ? { preimage: decodeHex32(record.preimageHex, "preimageHex") } : {}
+    };
+  }
+  const fallback = record.fallbackSecrets;
+  if (!fallback) return void 0;
+  if (fallback.version !== 1 || fallback.type !== "stored") {
+    throw new Error("unsupported RFQ fallback secrets record");
+  }
+  return {
+    derivable: false,
+    senderPrivateKey: decodeHex32(fallback.senderPrivateKeyHex, "senderPrivateKeyHex"),
+    ...fallback.preimageHex ? { preimage: decodeHex32(fallback.preimageHex, "preimageHex") } : {}
+  };
+}
+function decodeHex32(value, label) {
+  const bytes = import_base5.hex.decode(value);
+  if (bytes.length !== 32) {
+    throw new Error(label + " must be 32 bytes, got " + bytes.length);
+  }
+  return bytes;
+}
+async function adoptSwapDescriptor(wallet, signingDescriptor) {
+  if (!(0, import_sdk6.isHDAllocationCapable)(wallet)) return;
+  await wallet.advanceSigningDescriptorWatermark(signingDescriptor);
+}
+var RefundNotLocallyPossibleError = class extends Error {
+  constructor(reason, message, options) {
+    super(message, options);
+    this.reason = reason;
+  }
+  reason;
+  name = "RefundNotLocallyPossibleError";
+};
+async function senderIdentityForRfqSecrets(wallet, secrets) {
+  if (!secrets.derivable) return import_sdk6.SingleKey.fromPrivateKey(secrets.senderPrivateKey);
+  const signer = (0, import_sdk6.isHDWalletCapable)(wallet) ? await wallet.signerForDescriptor(secrets.signingDescriptor) : void 0;
+  if (!signer || !isDeterministicSigner(signer)) {
+    throw new RefundNotLocallyPossibleError(
+      "foreign-descriptor",
+      `this wallet cannot derive ${secrets.signingDescriptor}; the swap was created on another wallet`
+    );
+  }
+  return signer;
+}
+async function senderIdentityForSwapRecord(wallet, record) {
+  let secrets;
+  try {
+    secrets = rfqSecretsOfRecord(record);
+  } catch (error) {
+    throw new RefundNotLocallyPossibleError(
+      "unreadable-secrets",
+      error instanceof Error ? error.message : String(error),
+      // the record's own diagnosis, kept for a caller that wants more
+      // than the message
+      { cause: error }
+    );
+  }
+  if (!secrets) {
+    throw new RefundNotLocallyPossibleError(
+      "no-secrets",
+      "this swap record carries no signing descriptor and no fallback secrets"
+    );
+  }
+  return senderIdentityForRfqSecrets(wallet, secrets);
+}
+async function senderPubkeyForRfqSecrets(wallet, secrets) {
+  if (!secrets.derivable) return import_secp256k1.schnorr.getPublicKey(secrets.senderPrivateKey);
+  return (await senderIdentityForRfqSecrets(wallet, secrets)).xOnlyPublicKey();
+}
+function isDeterministicSigner(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.signSchnorrDeterministic === "function" && typeof v.xOnlyPublicKey === "function";
+}
+async function derivePreimage(signer) {
+  const xonly = await signer.xOnlyPublicKey();
+  const message = buildPreimageMessage(xonly, PREIMAGE_INDEX);
+  return (0, import_sha22.sha256)(await signer.signSchnorrDeterministic((0, import_sha22.sha256)(message)));
+}
+async function preimageForRfqSecrets(wallet, secrets) {
+  if (!secrets.derivable) {
+    if (!secrets.preimage) throw new Error("this swap carries no stored preimage");
+    return secrets.preimage;
+  }
+  if (secrets.preimage) return secrets.preimage;
+  const signer = await senderIdentityForRfqSecrets(wallet, secrets);
+  if (!isDeterministicSigner(signer)) {
+    throw new Error(
+      `wallet cannot sign deterministically for ${secrets.signingDescriptor}; its preimage is not derivable`
+    );
+  }
+  try {
+    return await derivePreimage(signer);
+  } catch (cause) {
+    throw new Error(
+      `wallet cannot sign deterministically for ${secrets.signingDescriptor}; its preimage is not derivable`,
+      { cause }
+    );
+  }
+}
+
+// src/claimPacket.ts
+var import_base6 = require("@scure/base");
+var import_secp256k12 = require("@noble/curves/secp256k1.js");
+var import_hkdf = require("@noble/hashes/hkdf.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+var HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
+async function sealClaimPacket(input) {
+  return sealWithEntropy(
+    input,
+    import_secp256k12.secp256k1.utils.randomSecretKey(),
+    crypto.getRandomValues(new Uint8Array(12))
+  );
+}
+async function sealWithEntropy(input, ephemeralKey, nonce) {
+  if (input.preimage.length !== 32) throw new Error("preimage must be 32 bytes");
+  if (input.covclaimdPubkey.length !== 33) {
+    throw new Error("covclaimd pubkey must be 33-byte compressed");
+  }
+  const ephemeralPub = import_secp256k12.secp256k1.getPublicKey(ephemeralKey, true);
+  const sharedX = import_secp256k12.secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
+  const key = (0, import_hkdf.hkdf)(import_sha23.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
+  if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
+  const aesKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, [
+    "encrypt"
+  ]);
+  const sealed = new Uint8Array(
+    await crypto.subtle.encrypt(
+      {
+        name: "AES-GCM",
+        iv: nonce,
+        additionalData: ephemeralPub
+      },
+      aesKey,
+      input.preimage
+    )
+  );
+  const packet = new Uint8Array(33 + 12 + sealed.length);
+  packet.set(ephemeralPub, 0);
+  packet.set(nonce, 33);
+  packet.set(sealed, 45);
+  return { ciphertext: import_base6.base64.encode(packet) };
+}
+
+// src/lockupContract.ts
+var import_base7 = require("@scure/base");
+var import_sdk7 = require("@arkade-os/sdk");
+var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
+var SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
+var SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
+var LockupRegistrationFailed = class extends Error {
+  /** The lockup address that was never registered — never fund it: nothing
+   * is watching it. */
+  address;
+  /** The covenant the row would have been written from — the other half of
+   * `registerLockupContract`, so the write is retryable without a quote. */
+  script;
+  constructor(script, address, cause) {
+    super(`failed to register the lockup contract for ${address}`, { cause });
+    this.name = "LockupRegistrationFailed";
+    this.address = address;
+    this.script = script;
+  }
+};
+async function registerLockupContract(contracts, script, address) {
+  try {
+    await contracts.createContract({
+      type: SWAP_LOCKUP_CONTRACT_TYPE,
+      params: import_sdk7.VHTLCV2ContractHandler.serializeParams(script.options),
+      script: import_base7.hex.encode(script.pkScript),
+      address,
+      label: SWAP_LOCKUP_CONTRACT_LABEL,
+      metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
+    });
+  } catch (error) {
+    throw new LockupRegistrationFailed(script, address, error);
+  }
+}
+
+// src/rfq.ts
+var xOnly2 = (key, label) => {
+  if (key.length === 32) return key;
+  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
+    throw new Error(`${label} is not a compressed or x-only public key`);
+  }
+  return key.slice(1);
+};
+var solverHex = (value, field) => {
+  try {
+    return import_base8.hex.decode(value);
+  } catch {
+    throw new Error(`solver sent malformed hex for ${field}`);
+  }
+};
+var ARKADE_BTC = "arkade:BTC";
+var ARKADE_ASSET = "arkade:ASSET";
+var LIGHTNING_BTC = "lightning:BTC";
+var ONCHAIN_BTC = "onchain:BTC";
+var rfqPair = (from, to) => `${from}->${to}`;
+var LIGHTNING_SEND_PAIR = rfqPair(ARKADE_BTC, LIGHTNING_BTC);
+var LIGHTNING_RECEIVE_PAIR = rfqPair(LIGHTNING_BTC, ARKADE_BTC);
+var ONCHAIN_SEND_PAIR = rfqPair(ARKADE_BTC, ONCHAIN_BTC);
+var ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
+var RFQ_TERMINAL_STATES = ["settled", "refused", "expired", "refunded", "stuck"];
+var SwapRefusal = class extends Error {
+  reason;
+  rfqId;
+  constructor(reason, rfqId) {
+    super(`solver refused: ${reason}`);
+    this.name = "SwapRefusal";
+    this.reason = reason;
+    this.rfqId = rfqId;
+  }
+};
+var AddressMismatch = class extends Error {
+  derived;
+  quoted;
+  constructor(derived, quoted) {
+    super("solver lockup address does not match local derivation \u2014 refusing to fund");
+    this.name = "AddressMismatch";
+    this.derived = derived;
+    this.quoted = quoted;
+  }
+};
+var newRfqId = () => import_base8.hex.encode(crypto.getRandomValues(new Uint8Array(32)));
+var lightningSendRequest = (input) => ({
+  v: 1,
+  type: "rfq_request",
+  rfq_id: input.rfqId,
+  pair: LIGHTNING_SEND_PAIR,
+  amount_side: "to",
+  profile: {
+    invoice: input.invoice,
+    refund_address: input.refundAddress,
+    client_refund_pubkey: import_base8.hex.encode(input.senderPubkey)
+  }
+});
+var arkadeSwapRequest = (input) => {
+  if (Boolean(input.wantAsset) === Boolean(input.offerAsset)) {
+    throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
+  }
+  return {
+    v: 1,
+    type: "rfq_request",
+    rfq_id: input.rfqId,
+    pair: rfqPair(
+      input.offerAsset ? ARKADE_ASSET : ARKADE_BTC,
+      input.wantAsset ? ARKADE_ASSET : ARKADE_BTC
+    ),
+    amount_side: input.amountSide,
+    amount: input.amount,
+    profile: {
+      ...input.offerAsset && { offer_asset: import_base8.hex.encode(input.offerAsset.serialize()) },
+      ...input.wantAsset && { want_asset: import_base8.hex.encode(input.wantAsset.serialize()) }
+    }
+  };
+};
+var MIN_HEADROOM_SECONDS = 90 * 60;
+var gateError = (reason, message) => {
+  const error = new Error(message);
+  error.reason = reason;
+  return error;
+};
+var assertFinite = (value, reason, label) => {
+  if (value !== void 0 && !Number.isFinite(value)) {
+    throw gateError(reason, `${label} is not a finite number (${String(value)})`);
+  }
+};
+var verifyLockupAddress = (quote, derivedAddress) => {
+  const quoted = quote.profile?.lockup_address;
+  if (derivedAddress !== quoted) throw new AddressMismatch(derivedAddress, quoted);
+  return derivedAddress;
+};
+var assertFundable = (input) => {
+  const fail = (reason, message) => {
+    throw gateError(reason, message);
+  };
+  if (input.invoiceExpiresAt !== void 0 && input.now >= input.invoiceExpiresAt) {
+    fail("invoice_expired", "invoice expired");
+  }
+  if (input.now >= input.quote.valid_until)
+    fail("quote_expired", "quote expired \u2014 request a fresh one");
+  if (input.quote.refund_locktime !== void 0 && input.quote.refund_locktime - input.now < MIN_HEADROOM_SECONDS) {
+    fail("insufficient_headroom", "refund deadline headroom below 90 minutes");
+  }
+  if (input.onchain) {
+    const { htlcLocktime, minConfirmations, direction } = input.onchain;
+    if (!Number.isInteger(minConfirmations) || minConfirmations < 1 || minConfirmations > MAX_MIN_CONFIRMATIONS) {
+      fail(
+        "confirmations_out_of_range",
+        `min_confirmations must be 1..${MAX_MIN_CONFIRMATIONS}, got ${minConfirmations}`
+      );
+    }
+    const needed = minConfirmations * ONCHAIN_SECONDS_PER_BLOCK + ONCHAIN_CLAIM_MARGIN_SECONDS;
+    if (htlcLocktime - input.now <= needed) {
+      fail("claim_window_too_short", "L1 HTLC locktime leaves no safe claim window");
+    }
+    if (direction === "send") {
+      if (input.quote.refund_locktime === void 0 || htlcLocktime + ONCHAIN_ORDER_MARGIN_SECONDS > input.quote.refund_locktime) {
+        fail(
+          "timelock_order",
+          "L1 HTLC locktime + margin must fall before the Arkade refund locktime"
+        );
+      }
+    }
+  }
+};
+var expectQuote = (payload, rfqId) => {
+  const p = payload;
+  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
+  if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
+    throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
+  }
+  return payload;
+};
+var httpTransport = (baseUrl, options = {}) => {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const readJson = async (response, what) => {
+    const body = await response.text();
+    try {
+      return JSON.parse(body);
+    } catch {
+      throw new Error(
+        `${what} returned HTTP ${response.status} with a non-JSON body: ${body.slice(0, 200)}`
+      );
+    }
+  };
+  return {
+    async requestQuote(payload) {
+      const response = await fetchImpl(`${baseUrl}/v1/swap`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      return expectQuote(await readJson(response, "quote request"), String(payload.rfq_id));
+    },
+    async status(rfqId) {
+      const response = await fetchImpl(`${baseUrl}/v1/rfq/${rfqId}`, { method: "GET" });
+      if (response.status === 404) return null;
+      const payload = await readJson(response, "status request");
+      return payload?.type === "rfq_status" ? payload : null;
+    },
+    async close() {
+    }
+  };
+};
+var relayTransport = (relayUrl, options) => {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const Ctor = options.WebSocketCtor ?? WebSocket;
+  const pending = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const socketReady = new Promise((resolve, reject) => {
+    const ws = new Ctor(relayUrl);
+    ws.addEventListener("open", () => {
+      ws.send(
+        JSON.stringify({
+          op: "sub",
+          id: "s1",
+          filter: { recipient: options.clientPubkey }
+        })
+      );
+      resolve(ws);
+    });
+    ws.addEventListener("error", () => reject(new Error("relay connection failed")));
+    ws.addEventListener("message", (event) => {
+      let frame;
+      try {
+        frame = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (frame.op !== "event") return;
+      const payload = frame.event?.payload;
+      const rfqId = payload?.rfq_id;
+      const settle = rfqId !== void 0 ? pending.get(rfqId) : void 0;
+      if (settle && rfqId !== void 0) {
+        pending.delete(rfqId);
+        settle(payload);
+      }
+    });
+  });
+  const roundTrip = async (payload, rfqId) => {
+    const ws = await socketReady;
+    const reply = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(rfqId);
+        reject(new Error(`no reply within ${timeoutMs}ms`));
+      }, timeoutMs);
+      pending.set(rfqId, (p) => {
+        clearTimeout(timer);
+        resolve(p);
+      });
+    });
+    ws.send(
+      JSON.stringify({
+        op: "event",
+        event: {
+          id: `${options.clientPubkey}:${sequence += 1}`,
+          author: options.clientPubkey,
+          recipient: options.solverPubkey,
+          createdAtMs: Date.now(),
+          payload
+        }
+      })
+    );
+    return reply;
+  };
+  return {
+    async requestQuote(payload) {
+      return expectQuote(
+        await roundTrip(payload, String(payload.rfq_id)),
+        String(payload.rfq_id)
+      );
+    },
+    async status(rfqId) {
+      const payload = await roundTrip(
+        { v: 1, type: "rfq_status_request", rfq_id: rfqId },
+        rfqId
+      );
+      return payload?.type === "rfq_status" ? payload : null;
+    },
+    async close() {
+      try {
+        (await socketReady).close();
+      } catch {
+      }
+    }
+  };
+};
+var SEQUENCE_GRANULARITY_SECONDS = 512;
+var unilateralClaimDelay = (serverExitDelaySeconds) => {
+  if (!Number.isFinite(serverExitDelaySeconds) || serverExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
+    throw new Error(
+      `server exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${serverExitDelaySeconds}`
+    );
+  }
+  if (serverExitDelaySeconds > (65535 - 2) * SEQUENCE_GRANULARITY_SECONDS) {
+    throw new Error(
+      `server exit delay ${serverExitDelaySeconds}s exceeds what BIP68 can encode once the two refund tiers are stacked above it`
+    );
+  }
+  return Math.ceil(serverExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
+};
+var unilateralRefundDelay = (claimDelay) => claimDelay + SEQUENCE_GRANULARITY_SECONDS;
+var unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + 2 * SEQUENCE_GRANULARITY_SECONDS;
+function lightningSendVtxoScript(params) {
+  const seconds = (value) => ({
+    type: "seconds",
+    value: BigInt(value)
+  });
+  return new import_sdk8.VHTLC.ScriptV2({
+    sender: params.senderPubkey,
+    receiver: params.solverPubkey,
+    server: params.serverPubkey,
+    preimageHash: (0, import_legacy2.ripemd160)(import_base8.hex.decode(params.paymentHash)),
+    refundLocktime: BigInt(params.refundLocktime),
+    unilateralClaimDelay: seconds(params.claimDelay),
+    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
+    unilateralRefundWithoutReceiverDelay: seconds(
+      unilateralRefundWithoutReceiverDelay(params.claimDelay)
+    ),
+    nonInteractiveClaim: {
+      receiverPkScript: params.receiverPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    },
+    nonInteractiveRefund: {
+      senderPkScript: params.refundPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    }
+  });
+}
+async function requestLightningSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets();
+  if (!secrets.derivable) {
+    console.warn(
+      "[swap] wallet cannot allocate an HD descriptor: the sender key is random and MUST be persisted before funding"
+    );
+  }
+  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, refundAddress] = await Promise.all([
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const quote = await transport.requestQuote(
+    lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
+  );
+  if (quote.refund_locktime === void 0) {
+    throw new Error("lightning-send quote is missing refund_locktime");
+  }
+  const receiverPkScriptHex = quote.profile?.receiver_pk_script;
+  if (receiverPkScriptHex === void 0) {
+    throw new Error("lightning-send quote is missing profile.receiver_pk_script");
+  }
+  if (quote.to_amount !== params.invoice.amountSats) {
+    throw new Error(
+      `quote to_amount ${quote.to_amount} does not match the invoice's ${params.invoice.amountSats}`
+    );
+  }
+  if (quote.from_amount < quote.to_amount) {
+    throw new Error(
+      `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
+    );
+  }
+  const serverPubkey = xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key");
+  const script = lightningSendVtxoScript({
+    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime: quote.refund_locktime,
+    serverPubkey,
+    paymentHash: params.invoice.paymentHash,
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: import_sdk8.ArkAddress.decode(refundAddress).pkScript
+  });
+  const address = script.address((0, import_sdk8.getNetwork)(info.network).hrp, serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  assertFundable({
+    quote,
+    invoiceExpiresAt: params.invoice.expiresAt,
+    now: Math.floor(Date.now() / 1e3)
+  });
+  await registerLockupContract(await wallet.getContractManager(), script, address);
+  return {
+    rfqId,
+    quote,
+    address,
+    // What the lockup must carry: the quote's `from_amount` — the invoice
+    // PLUS the corridor's fee, never the bare invoice amount.
+    fundAmount: quote.from_amount,
+    swapPkScript: script.pkScript,
+    script,
+    refundAddress,
+    senderPubkey,
+    secrets
+  };
+}
+var offerTermsFromQuote = (quote, assets) => {
+  if (Boolean(assets.wantAsset) === Boolean(assets.offerAsset)) {
+    throw new Error("set exactly one of wantAsset or offerAsset");
+  }
+  return { wantAmount: BigInt(quote.to_amount), ...assets };
+};
+var l1NetworkFromArk = (network) => network === "bitcoin" ? "bitcoin" : network === "regtest" ? "regtest" : "testnet";
+var onchainSendRequest = (input) => ({
+  v: 1,
+  type: "rfq_request",
+  rfq_id: input.rfqId,
+  pair: ONCHAIN_SEND_PAIR,
+  amount_side: input.amountSide,
+  amount: input.amount,
+  profile: {
+    payment_hash: input.paymentHash,
+    payout_pubkey: import_base8.hex.encode(input.payoutPubkey),
+    refund_address: input.refundAddress,
+    client_refund_pubkey: import_base8.hex.encode(input.senderPubkey)
+  }
+});
+var lightningReceiveRequest = (input) => ({
+  v: 1,
+  type: "rfq_request",
+  rfq_id: input.rfqId,
+  pair: LIGHTNING_RECEIVE_PAIR,
+  amount_side: input.amountSide,
+  amount: input.amount,
+  profile: {
+    payment_hash: input.paymentHash,
+    payout_address: input.payoutAddress,
+    payout_pubkey: import_base8.hex.encode(input.payoutPubkey),
+    claim_packet: input.claimPacket
+  }
+});
+var onchainReceiveRequest = (input) => ({
+  v: 1,
+  type: "rfq_request",
+  rfq_id: input.rfqId,
+  pair: ONCHAIN_RECEIVE_PAIR,
+  amount_side: input.amountSide,
+  amount: input.amount,
+  profile: {
+    payment_hash: input.paymentHash,
+    claim_packet: input.claimPacket,
+    refund_pubkey: import_base8.hex.encode(input.refundPubkey),
+    payout_address: input.payoutAddress,
+    payout_pubkey: import_base8.hex.encode(input.payoutPubkey)
+  }
+});
+function deriveOnchainSend(input) {
+  const { quote } = input;
+  const profile = quote.profile ?? {};
+  const refundLocktime = quote.refund_locktime ?? profile.refund_locktime;
+  const htlcPubkey = profile.htlc_pubkey;
+  const htlcLocktime = profile.htlc_locktime;
+  const htlcAddress = profile.htlc_address;
+  const minConfirmations = profile.min_confirmations;
+  const receiverPkScriptHex = profile.receiver_pk_script;
+  if (refundLocktime === void 0 || htlcPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || receiverPkScriptHex === void 0) {
+    throw new Error("onchain-send quote is missing a binding field");
+  }
+  const script = lightningSendVtxoScript({
+    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    serverPubkey: input.serverPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    senderPubkey: input.senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: import_sdk8.ArkAddress.decode(input.refundAddress).pkScript
+  });
+  const address = script.address(input.hrp, input.serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  const htlc = onchainHtlcScript(
+    {
+      paymentHash: input.paymentHash,
+      claimKey: input.payoutPubkey,
+      refundKey: xOnly2(import_base8.hex.decode(htlcPubkey), "solver L1 htlc key"),
+      refundLocktime: htlcLocktime
+    },
+    input.l1Network
+  );
+  if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
+  return {
+    address,
+    swapPkScript: script.pkScript,
+    script,
+    htlc,
+    refundLocktime,
+    htlcLocktime,
+    minConfirmations
+  };
+}
+async function requestOnchainSend(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  if (params.preimage && params.preimage.length !== 32) {
+    throw new Error(`preimage must be 32 bytes, got ${params.preimage.length}`);
+  }
+  const derivedSecrets = await deriveSwapSecrets(wallet);
+  const secrets = derivedSecrets ? params.preimage ? { ...derivedSecrets, preimage: params.preimage } : derivedSecrets : randomSwapSecrets({ preimage: params.preimage ?? true });
+  if (!secrets.derivable) {
+    console.warn(
+      params.preimage ? "[swap] this swap's sender key is random; the supplied preimage and sender key MUST be persisted before funding" : "[swap] this swap's preimage and sender key are random and MUST be persisted before funding"
+    );
+  } else if (params.preimage) {
+    console.warn(
+      "[swap] this swap's preimage was supplied by the caller and MUST be persisted with the signing descriptor before funding"
+    );
+  }
+  const preimage = await preimageForRfqSecrets(wallet, secrets);
+  const paymentHash = paymentHashOf(preimage);
+  const senderPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, refundAddress] = await Promise.all([
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const quote = await transport.requestQuote(
+    onchainSendRequest({
+      rfqId,
+      paymentHash,
+      payoutPubkey: params.payoutPubkey,
+      refundAddress,
+      senderPubkey,
+      amount: params.amount,
+      amountSide: params.amountSide
+    })
+  );
+  const derived = deriveOnchainSend({
+    quote,
+    paymentHash,
+    payoutPubkey: params.payoutPubkey,
+    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: (0, import_sdk8.getNetwork)(info.network).hrp,
+    l1Network: l1NetworkFromArk(info.network),
+    refundAddress,
+    senderPubkey
+  });
+  assertFundable({
+    quote,
+    now: Math.floor(Date.now() / 1e3),
+    onchain: {
+      htlcLocktime: derived.htlcLocktime,
+      minConfirmations: derived.minConfirmations,
+      direction: "send"
+    }
+  });
+  await registerLockupContract(
+    await wallet.getContractManager(),
+    derived.script,
+    derived.address
+  );
+  return {
+    rfqId,
+    quote,
+    address: derived.address,
+    fundAmount: quote.from_amount,
+    swapPkScript: derived.swapPkScript,
+    script: derived.script,
+    refundAddress,
+    htlc: derived.htlc,
+    senderPubkey,
+    secrets
+  };
+}
+var assertQuotedAmount = (quote, amountSide, amount) => {
+  const quoted = amountSide === "from" ? quote.from_amount : quote.to_amount;
+  if (quoted !== amount) {
+    throw new Error(
+      `quote ${amountSide === "from" ? "from_amount" : "to_amount"} ${quoted} does not match the requested ${amount} \u2014 not this trade's quote`
+    );
+  }
+  if (quote.to_amount > quote.from_amount) {
+    throw new Error("quote pays out more than it takes in \u2014 not a quote to fund");
+  }
+};
+var MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
+var verifyReceiveInvoice = (input) => {
+  let decoded;
+  try {
+    decoded = input.decode(input.invoice);
+  } catch (error) {
+    throw gateError(
+      "invoice_undecodable",
+      `solver sent an undecodable invoice: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  assertFinite(decoded.expiresAt, "invoice_undecodable", "the decoded invoice expiry");
+  assertFinite(input.quote.valid_until, "quote_malformed", "quote valid_until");
+  if (decoded.paymentHash !== input.paymentHash) {
+    throw gateError(
+      "invoice_hash_mismatch",
+      `solver's invoice pays ${decoded.paymentHash}, not this swap's ${input.paymentHash}`
+    );
+  }
+  if (decoded.amountSats <= 0) {
+    throw gateError("invoice_amount_mismatch", "solver's invoice names no amount");
+  }
+  if (decoded.amountSats !== input.quote.from_amount) {
+    throw gateError(
+      "invoice_amount_mismatch",
+      `solver's invoice asks for ${decoded.amountSats}, not the quoted from_amount ${input.quote.from_amount}`
+    );
+  }
+  return { payDeadline: Math.min(decoded.expiresAt, input.quote.valid_until) };
+};
+var assertReceivable = (input) => {
+  assertFinite(input.payDeadline, "quote_malformed", "payDeadline");
+  assertFinite(input.now, "invalid_gate_input", "now");
+  assertFinite(input.minClaimWindowSeconds, "invalid_gate_input", "minClaimWindowSeconds");
+  assertFinite(input.maxPayAmount, "invalid_gate_input", "maxPayAmount");
+  const minClaimWindow = input.minClaimWindowSeconds ?? MIN_CLAIM_WINDOW_SECONDS;
+  if (input.now >= input.payDeadline) {
+    throw gateError("quote_expired", "quote or invoice already expired \u2014 request a fresh one");
+  }
+  if (input.quote.refund_locktime === void 0) {
+    throw gateError("missing_refund_locktime", "receive quote carries no refund_locktime");
+  }
+  assertFinite(input.quote.refund_locktime, "quote_malformed", "quote refund_locktime");
+  if (input.quote.refund_locktime - input.payDeadline < minClaimWindow) {
+    throw gateError(
+      "claim_window_too_short",
+      `a payment at the deadline would leave under ${minClaimWindow}s to claim before the solver's refund opens`
+    );
+  }
+  if (input.maxPayAmount !== void 0 && input.quote.from_amount > input.maxPayAmount) {
+    throw gateError(
+      "price_too_high",
+      `quote asks ${input.quote.from_amount} sats, above the ${input.maxPayAmount} ceiling`
+    );
+  }
+};
+function receiveVtxoScript(params) {
+  const seconds = (value) => ({
+    type: "seconds",
+    value: BigInt(value)
+  });
+  return new import_sdk8.VHTLC.ScriptV2({
+    sender: params.solverPubkey,
+    receiver: params.payoutPubkey,
+    server: params.serverPubkey,
+    preimageHash: (0, import_legacy2.ripemd160)(import_base8.hex.decode(params.paymentHash)),
+    refundLocktime: BigInt(params.refundLocktime),
+    unilateralClaimDelay: seconds(params.claimDelay),
+    unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
+    unilateralRefundWithoutReceiverDelay: seconds(
+      unilateralRefundWithoutReceiverDelay(params.claimDelay)
+    ),
+    nonInteractiveClaim: {
+      receiverPkScript: params.payoutPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    },
+    nonInteractiveRefund: {
+      senderPkScript: params.solverRefundPkScript,
+      emulatorPubkey: params.emulatorPubkey
+    }
+  });
+}
+function deriveLightningReceive(input) {
+  const { quote } = input;
+  const profile = quote.profile ?? {};
+  const refundLocktime = quote.refund_locktime;
+  const invoice = profile.invoice;
+  const solverRefundPkScriptHex = profile.solver_refund_pk_script;
+  if (refundLocktime === void 0 || invoice === void 0 || solverRefundPkScriptHex === void 0) {
+    throw new Error("lightning-receive quote is missing a binding field");
+  }
+  const script = receiveVtxoScript({
+    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    serverPubkey: input.serverPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
+    payoutPubkey: input.payoutPubkey,
+    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
+  });
+  const address = script.address(input.hrp, input.serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime };
+}
+async function requestLightningReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
+  if (!secrets.derivable) {
+    console.warn(
+      "[swap] this swap's preimage and payout key are random and MUST be persisted before paying"
+    );
+  }
+  const preimage = await preimageForRfqSecrets(wallet, secrets);
+  const paymentHash = paymentHashOf(preimage);
+  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, payoutAddress] = await Promise.all([
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const claimPacket = await sealClaimPacket({
+    preimage,
+    covclaimdPubkey: params.covclaimdPubkey
+  });
+  const quote = await transport.requestQuote(
+    lightningReceiveRequest({
+      rfqId,
+      paymentHash,
+      payoutAddress,
+      payoutPubkey,
+      claimPacket: claimPacket.ciphertext,
+      amount: params.amount,
+      amountSide: params.amountSide
+    })
+  );
+  assertQuotedAmount(quote, params.amountSide, params.amount);
+  const derived = deriveLightningReceive({
+    quote,
+    paymentHash,
+    payoutPubkey,
+    payoutAddress,
+    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: (0, import_sdk8.getNetwork)(info.network).hrp
+  });
+  const now = Math.floor(Date.now() / 1e3);
+  const { payDeadline } = verifyReceiveInvoice({
+    invoice: derived.invoice,
+    decode: params.decodeInvoice,
+    paymentHash,
+    quote
+  });
+  assertReceivable({ quote, payDeadline, now, maxPayAmount: params.maxPayAmount });
+  await registerLockupContract(
+    await wallet.getContractManager(),
+    derived.script,
+    derived.address
+  );
+  return {
+    rfqId,
+    quote,
+    invoice: derived.invoice,
+    payAmount: quote.from_amount,
+    expectedAmount: quote.to_amount,
+    invoiceExpiresAt: payDeadline,
+    address: derived.address,
+    swapPkScript: derived.swapPkScript,
+    script: derived.script,
+    payoutAddress,
+    payoutPubkey,
+    secrets
+  };
+}
+function deriveOnchainReceive(input) {
+  const { quote } = input;
+  const profile = quote.profile ?? {};
+  const refundLocktime = quote.refund_locktime;
+  const claimPubkey = profile.claim_pubkey;
+  const htlcLocktime = profile.htlc_locktime;
+  const htlcAddress = profile.htlc_address;
+  const minConfirmations = profile.min_confirmations;
+  const solverRefundPkScriptHex = profile.solver_refund_pk_script;
+  if (refundLocktime === void 0 || claimPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || solverRefundPkScriptHex === void 0) {
+    throw new Error("onchain-receive quote is missing a binding field");
+  }
+  const script = receiveVtxoScript({
+    solverPubkey: xOnly2(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime,
+    serverPubkey: input.serverPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
+    payoutPubkey: input.payoutPubkey,
+    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
+  });
+  const address = script.address(input.hrp, input.serverPubkey).encode();
+  verifyLockupAddress(quote, address);
+  const htlc = onchainHtlcScript(
+    {
+      paymentHash: input.paymentHash,
+      claimKey: xOnly2(import_base8.hex.decode(claimPubkey), "solver L1 claim key"),
+      refundKey: input.refundPubkey,
+      refundLocktime: htlcLocktime
+    },
+    input.l1Network
+  );
+  if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
+  return {
+    address,
+    swapPkScript: script.pkScript,
+    script,
+    htlc,
+    refundLocktime,
+    htlcLocktime,
+    minConfirmations
+  };
+}
+async function requestOnchainReceive(wallet, arkServerUrl, emulatorPubkey, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  const secrets = await deriveSwapSecrets(wallet) ?? randomSwapSecrets({ preimage: true });
+  if (!secrets.derivable) {
+    console.warn(
+      "[swap] this swap's preimage and payout key are random and MUST be persisted before funding"
+    );
+  }
+  const preimage = await preimageForRfqSecrets(wallet, secrets);
+  const paymentHash = paymentHashOf(preimage);
+  const payoutPubkey = await senderPubkeyForRfqSecrets(wallet, secrets);
+  const [info, payoutAddress] = await Promise.all([
+    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress()
+  ]);
+  const claimPacket = await sealClaimPacket({
+    preimage,
+    covclaimdPubkey: params.covclaimdPubkey
+  });
+  const quote = await transport.requestQuote(
+    onchainReceiveRequest({
+      rfqId,
+      paymentHash,
+      payoutAddress,
+      payoutPubkey,
+      refundPubkey: params.refundPubkey,
+      claimPacket: claimPacket.ciphertext,
+      amount: params.amount,
+      amountSide: params.amountSide
+    })
+  );
+  assertQuotedAmount(quote, params.amountSide, params.amount);
+  const derived = deriveOnchainReceive({
+    quote,
+    paymentHash,
+    payoutPubkey,
+    payoutAddress,
+    refundPubkey: params.refundPubkey,
+    serverPubkey: xOnly2(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: xOnly2(emulatorPubkey, "emulator pubkey"),
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: (0, import_sdk8.getNetwork)(info.network).hrp,
+    l1Network: l1NetworkFromArk(info.network)
+  });
+  assertFundable({
+    quote,
+    now: Math.floor(Date.now() / 1e3),
+    onchain: {
+      htlcLocktime: derived.htlcLocktime,
+      minConfirmations: derived.minConfirmations,
+      direction: "receive"
+    }
+  });
+  await registerLockupContract(
+    await wallet.getContractManager(),
+    derived.script,
+    derived.address
+  );
+  return {
+    rfqId,
+    quote,
+    address: derived.address,
+    fundAmount: quote.from_amount,
+    expectedAmount: quote.to_amount,
+    swapPkScript: derived.swapPkScript,
+    script: derived.script,
+    htlc: derived.htlc,
+    payoutAddress,
+    payoutPubkey,
+    secrets
+  };
+}
+
+// src/claim.ts
+var import_base10 = require("@scure/base");
+var import_legacy3 = require("@noble/hashes/legacy.js");
+var import_sha25 = require("@noble/hashes/sha2.js");
+var import_sdk10 = require("@arkade-os/sdk");
+
+// src/refund.ts
+var import_base9 = require("@scure/base");
+var import_sha24 = require("@noble/hashes/sha2.js");
+var import_sdk9 = require("@arkade-os/sdk");
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isRfqTerminal = (state) => RFQ_TERMINAL_STATES.includes(state);
+var RFQ_RESOLVED_STATES = ["settled", "refunded"];
+var isResolved = (state) => RFQ_RESOLVED_STATES.includes(state);
+async function awaitRfqResolution(transport, rfqId, options = {}) {
+  const pollMs = options.pollMs ?? 5e3;
+  for (; ; ) {
+    const status = await transport.status(rfqId);
+    if (status && isRfqTerminal(status.state)) return status;
+    if (options.deadline !== void 0 && Date.now() / 1e3 >= options.deadline) {
+      const error = new Error(
+        `rfq ${rfqId} did not reach a terminal state before the deadline`
+      );
+      error.reason = "status_timeout";
+      throw error;
+    }
+    await sleep2(pollMs);
+  }
+}
+var LockupNeedsRecoveryError = class extends Error {
+  name = "LockupNeedsRecoveryError";
+  reason = "needs_recovery";
+  /** `txid:vout` for each output that must be recovered first. */
+  outpoints;
+  /**
+   * The contract's `refundLocktime`. Recovering before this matures is the
+   * hazard described above: `recoverVtxos()` sweeps EVERY recoverable output
+   * into one settlement with no CLTV awareness, so an early attempt can fail
+   * the whole batch — including unrelated outputs that were otherwise fine.
+   *
+   * Exposed as a value, not only inside the message, so a caller can encode
+   * `packages/boltz-swap`'s "pre-CLTV recoverable → skipped" rule without
+   * parsing prose. Seconds-based locktimes mature against the chain tip's
+   * timestamp rather than wall clock, so treat this as a floor to wait past,
+   * not an exact alarm.
+   */
+  recoverableAfter;
+  constructor(outpoints, recoverableAfter) {
+    super(
+      `refund refused: ${outpoints.length} lockup output(s) have been swept and can no longer be spent offchain (${outpoints.join(", ")}). Recover them into a fresh batch first \u2014 IVtxoManager.recoverVtxos() does this for a wallet whose contract manager has the lockup registered, once refundLocktime (${recoverableAfter}) has matured \u2014 then retry the refund. Recovering before then can fail the entire settlement, not just these outputs.`
+    );
+    this.outpoints = outpoints;
+    this.recoverableAfter = recoverableAfter;
+  }
+};
+async function findLockupVtxos(indexer, swapPkScript) {
+  const scripts = [import_base9.hex.encode(swapPkScript)];
+  const [spendable, recoverable] = await Promise.all([
+    indexer.getVtxos({ scripts, spendableOnly: true }),
+    indexer.getVtxos({ scripts, recoverableOnly: true })
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const [vtxos, isRecoverable] of [
+    [spendable.vtxos ?? [], false],
+    [recoverable.vtxos ?? [], true]
+  ]) {
+    for (const vtxo of vtxos) {
+      const key = `${vtxo.txid}:${vtxo.vout}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({
+        txid: vtxo.txid,
+        vout: vtxo.vout,
+        value: Number(vtxo.value),
+        recoverable: isRecoverable
+      });
+    }
+  }
+  return out;
+}
+var hashesTo = (candidate, paymentHash) => import_base9.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
+var candidateWitnessItems = (tx, inputIndex) => [
+  ...(0, import_sdk9.getArkPsbtFields)(tx, inputIndex, import_sdk9.ConditionWitness).flat(),
+  ...tx.getInput(inputIndex).finalScriptWitness ?? []
+];
+async function readLockupFate(indexer, input) {
+  const { vtxos } = await indexer.getVtxos({ scripts: [import_base9.hex.encode(input.swapPkScript)] });
+  const all = vtxos ?? [];
+  if (all.length === 0) return { fate: "unknown" };
+  const spentBy = /* @__PURE__ */ new Set();
+  let everySpendNamed = true;
+  for (const vtxo of all) {
+    if (!vtxo.isSpent && !vtxo.spentBy && !vtxo.settledBy) return { fate: "open" };
+    if (vtxo.spentBy) spentBy.add(vtxo.spentBy);
+    else everySpendNamed = false;
+  }
+  const { txs } = await indexer.getVirtualTxs([...spentBy]);
+  const observed = /* @__PURE__ */ new Set();
+  for (const raw of txs) {
+    let tx;
+    try {
+      tx = import_sdk9.Transaction.fromPSBT(import_base9.base64.decode(raw));
+    } catch {
+      continue;
+    }
+    if (spentBy.has(tx.id)) observed.add(tx.id);
+    for (let i = 0; i < tx.inputsLength; i++) {
+      const spent = tx.getInput(i);
+      if (!spent.txid) continue;
+      const txid = import_base9.hex.encode(spent.txid);
+      if (!all.some((vtxo) => vtxo.txid === txid && vtxo.vout === spent.index)) continue;
+      for (const candidate of candidateWitnessItems(tx, i)) {
+        if (hashesTo(candidate, input.paymentHash)) {
+          return { fate: "claimed", preimage: candidate };
+        }
+      }
+    }
+  }
+  return everySpendNamed && observed.size === spentBy.size ? { fate: "returned" } : { fate: "unknown" };
+}
+async function pushRefundWithoutReceiver(ark, input) {
+  if (input.vtxos.length === 0) throw new Error("nothing to refund: no funded outputs");
+  const swept = input.vtxos.filter((vtxo) => vtxo.recoverable);
+  if (swept.length > 0) {
+    throw new LockupNeedsRecoveryError(
+      swept.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`),
+      input.script.options.refundLocktime
+    );
+  }
+  const refundPkScript = input.refundPkScript ?? input.script.options.nonInteractiveRefund?.senderPkScript;
+  if (!refundPkScript) {
+    throw new Error(
+      "no refund destination: the contract carries no nonInteractiveRefund leaf, so pass refundPkScript explicitly"
+    );
+  }
+  const info = await ark.getInfo();
+  let serverUnrollScript;
+  try {
+    serverUnrollScript = import_sdk9.CSVMultisigTapscript.decode(import_base9.hex.decode(info.checkpointTapscript));
+  } catch {
+    throw new Error("invalid checkpointTapscript from the Arkade server");
+  }
+  const leaf = input.script.refundWithoutReceiver();
+  const tapTree = input.script.encode();
+  const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
+  const { arkTx, checkpoints } = (0, import_sdk9.buildOffchainTx)(
+    input.vtxos.map((vtxo) => ({
+      txid: vtxo.txid,
+      vout: vtxo.vout,
+      value: vtxo.value,
+      tapLeafScript: leaf,
+      tapTree
+    })),
+    [{ script: refundPkScript, amount: BigInt(amount) }],
+    serverUnrollScript
+  );
+  const signedArkTx = await input.sender.sign(arkTx);
+  const submitted = await ark.submitTx(
+    import_base9.base64.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => import_base9.base64.encode(c.toPSBT()))
+  );
+  (0, import_sdk9.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
+  const matched = (0, import_sdk9.matchServerCheckpoints)(
+    submitted.signedCheckpointTxs,
+    checkpoints,
+    "refundWithoutReceiver"
+  );
+  const finalCheckpoints = await Promise.all(
+    matched.map(
+      async ({ server }) => import_base9.base64.encode((await input.sender.sign(server, [0])).toPSBT())
+    )
+  );
+  await ark.finalizeTx(submitted.arkTxid, finalCheckpoints);
+  return { arkTxid: submitted.arkTxid, amount };
+}
+var REFUND_MTP_LAG_SECONDS = 2 * 60 * 60;
+async function refundIfUnresolved(transport, ark, indexer, input) {
+  const pollMs = input.pollMs ?? 5e3;
+  const now = input.now ?? (() => Math.floor(Date.now() / 1e3));
+  const attemptDeadline = input.attemptDeadline ?? input.refundLocktime + REFUND_MTP_LAG_SECONDS;
+  for (; ; ) {
+    const status = await transport.status(input.rfqId);
+    if (status && isResolved(status.state)) return { outcome: "resolved", status };
+    if (now() >= input.refundLocktime) {
+      const vtxos = await findLockupVtxos(indexer, input.script.pkScript);
+      if (vtxos.length === 0) return { outcome: "nothing_to_refund", status };
+      try {
+        const pushed = await pushRefundWithoutReceiver(ark, {
+          script: input.script,
+          sender: input.sender,
+          vtxos,
+          refundPkScript: input.refundPkScript
+        });
+        return { outcome: "refunded", status, ...pushed };
+      } catch (error) {
+        if (error instanceof LockupNeedsRecoveryError) {
+          return {
+            outcome: "needs_recovery",
+            outpoints: error.outpoints,
+            vtxos,
+            status
+          };
+        }
+        if (now() >= attemptDeadline) throw error;
+      }
+    }
+    await sleep2(pollMs);
+  }
+}
+
+// src/claim.ts
+var sleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var LockupAmountMismatchError = class extends Error {
+  name = "LockupAmountMismatchError";
+  reason = "amount_mismatch";
+  expectedAmount;
+  lockedAmount;
+  constructor(expectedAmount, lockedAmount) {
+    super(
+      `lockup holds ${lockedAmount} sats, below the agreed ${expectedAmount} \u2014 refusing to publish the preimage`
+    );
+    this.expectedAmount = expectedAmount;
+    this.lockedAmount = lockedAmount;
+  }
+};
+var assertFiniteAmount = (value, reason, label) => {
+  if (Number.isFinite(value)) return;
+  const error = new Error(`${label} is not a finite number (${String(value)})`);
+  error.reason = reason;
+  throw error;
+};
+async function pushClaim(ark, input) {
+  if (input.vtxos.length === 0) throw new Error("nothing to claim: no funded outputs");
+  const swept = input.vtxos.filter((vtxo) => vtxo.recoverable);
+  if (swept.length > 0) {
+    throw new LockupNeedsRecoveryError(
+      swept.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`),
+      input.script.options.refundLocktime
+    );
+  }
+  const locked = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
+  assertFiniteAmount(locked, "lockup_malformed", "the lockup's summed value");
+  if (!input.partiallyClaimed) {
+    assertFiniteAmount(input.expectedAmount, "invalid_gate_input", "expectedAmount");
+    if (locked < input.expectedAmount) {
+      throw new LockupAmountMismatchError(input.expectedAmount, locked);
+    }
+  }
+  const committed = input.script.options.preimageHash;
+  if (import_base10.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base10.hex.encode(committed)) {
+    throw new Error("preimage does not match the covenant's payment hash");
+  }
+  const info = await ark.getInfo();
+  let serverUnrollScript;
+  try {
+    serverUnrollScript = import_sdk10.CSVMultisigTapscript.decode(import_base10.hex.decode(info.checkpointTapscript));
+  } catch {
+    throw new Error("invalid checkpointTapscript from the Arkade server");
+  }
+  const leaf = input.script.claim();
+  const tapTree = input.script.encode();
+  const arkTxid = await (0, import_sdk10.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk10.claimWithPreimageIdentity)(input.receiver, input.preimage),
+    provider: ark,
+    inputs: input.vtxos.map((vtxo) => ({
+      txid: vtxo.txid,
+      vout: vtxo.vout,
+      value: vtxo.value,
+      tapLeafScript: leaf,
+      tapTree
+    })),
+    // One aggregate output: unlike the covenant refund, this leaf inspects
+    // nothing about the output set.
+    outputs: [{ script: input.destinationPkScript, amount: BigInt(locked) }],
+    serverUnrollScript,
+    verifyServerSignatures: { serverPubkey: input.script.options.server }
+  });
+  return { arkTxid, amount: locked };
+}
+async function awaitLockupFunding(indexer, swapPkScript, options = {}) {
+  const pollMs = options.pollMs ?? 5e3;
+  for (; ; ) {
+    const vtxos = await findLockupVtxos(indexer, swapPkScript);
+    if (vtxos.length > 0) return vtxos;
+    if (options.deadline !== void 0 && Date.now() / 1e3 >= options.deadline) {
+      const error = new Error("the lockup never appeared at the covenant script");
+      error.reason = "lockup_timeout";
+      throw error;
+    }
+    await sleep3(pollMs);
+  }
+}
+async function claimReceiveLockup(indexer, ark, input) {
+  const vtxos = await awaitLockupFunding(indexer, input.swapPkScript, {
+    pollMs: input.pollMs,
+    deadline: input.deadline
+  });
+  return pushClaim(ark, {
+    script: input.script,
+    receiver: input.receiver,
+    preimage: input.preimage,
+    vtxos,
+    destinationPkScript: input.destinationPkScript,
+    expectedAmount: input.expectedAmount,
+    partiallyClaimed: input.partiallyClaimed
+  });
+}
+
+// src/swapManager.ts
+var import_base11 = require("@scure/base");
+var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
+var isRfqSwapTerminal = (state) => RFQ_SWAP_TERMINAL_STATES.includes(state);
+function nextOnchainAction(input) {
+  switch (input.phase.phase) {
+    case "unfunded":
+    case "awaiting_confirmations":
+      return "wait";
+    case "claimed":
+      return "claimed";
+    case "swept":
+      return "swept";
+    case "refundable":
+      return "claim_window_closed";
+    case "claimable":
+      return input.htlcLocktime - input.now >= ONCHAIN_CLAIM_MARGIN_SECONDS ? "claim" : "claim_window_closed";
+  }
+}
+var notify = (listeners, call) => {
+  for (const listener of listeners) {
+    try {
+      call(listener);
+    } catch {
+    }
+  }
+};
+var RfqSwapManager = class {
+  deps;
+  config;
+  callbacks = null;
+  swapUpdateListeners = /* @__PURE__ */ new Set();
+  swapCompletedListeners = /* @__PURE__ */ new Set();
+  swapFailedListeners = /* @__PURE__ */ new Set();
+  actionExecutedListeners = /* @__PURE__ */ new Set();
+  monitored = /* @__PURE__ */ new Map();
+  /** Monitored swaps by lockup script hex, so a contract event — which names
+   * a script and nothing else — can find the swap it belongs to. */
+  byLockupScript = /* @__PURE__ */ new Map();
+  /**
+   * Swaps whose lockup registration has been SETTLED one way or another,
+   * mapped to whether a contract row actually resulted. Membership is what
+   * stops a per-pass retry from becoming a per-pass round trip; the value is
+   * what keeps a swap that could never be registered from later trying to
+   * retire a row that does not exist, which would report a spurious failure
+   * on a swap that in fact succeeded.
+   */
+  registered = /* @__PURE__ */ new Map();
+  /**
+   * Swaps whose `refundArkade` answered {@link RefundNotLocallyPossibleError}
+   * in this process. Membership stops the push from being re-issued every
+   * pass — it cannot start working on its own, and re-issuing it is the
+   * grind `needs_counterparty` exists to remove. Only
+   * {@link RfqSwapManagerCallbacks.canRefundArkade} clears it, so a caller
+   * with no probe learns again on the next start, when the wallet that can
+   * sign may well have been restored.
+   */
+  refundRefused = /* @__PURE__ */ new Set();
+  /**
+   * The last error a receive swap's claim callback threw, by rfqId.
+   *
+   * Kept only to tell two terminal outcomes apart once the claim window
+   * shuts: a swap whose claim was attempted and kept failing ends `failed`
+   * with that reason, while one that simply never became claimable ends
+   * `refunded`. Without it a broken claim callback would resolve a caller's
+   * {@link waitForSwapCompletion} as an ordinary unwind.
+   *
+   * Process-local, like {@link refundRefused}: after a restart the same swap
+   * ends `refunded` instead, which costs the caller a reason and nothing else
+   * — every throw was already reported through `onSwapFailed` as it happened.
+   */
+  lastClaimError = /* @__PURE__ */ new Map();
+  /**
+   * The lockup outpoints a receive swap's claim callback has already been
+   * handed, by rfqId.
+   *
+   * What this exists to prevent: a claim SUCCEEDS, and for the next few
+   * passes the indexer still lists those outputs as unspent. Without a
+   * record of what was already claimed, every one of those passes would
+   * re-submit the same spend, fail against the server, and report a swap
+   * that in fact worked as failing. With one, a re-claim happens only when
+   * an outpoint appears that was never claimed — a lockup funded piecemeal,
+   * which is legitimate and which `partiallyClaimed` exists for.
+   *
+   * Process-local: after a restart a swap with a live claim tries once more.
+   * That is the recovery case rather than the spam one — a claim that never
+   * landed leaves its outputs unspent, and one that did leaves a single
+   * rejection.
+   */
+  claimedOutpoints = /* @__PURE__ */ new Map();
+  /** Live `onContractEvent` subscription, held so `stop()` can drop it. */
+  unsubscribeContracts = null;
+  /** Terminal records, kept so a late {@link waitForSwapCompletion} still
+   * answers instead of throwing "not found". Cleared by {@link removeSwap}. */
+  finished = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Map();
+  /** Records changed during the current pass, flushed through `saveSwap`. */
+  dirty = /* @__PURE__ */ new Set();
+  /** Race guard: one action at a time per swap. */
+  inProgress = /* @__PURE__ */ new Set();
+  timer = null;
+  running = false;
+  constructor(deps, config = {}) {
+    this.deps = deps;
+    this.config = {
+      enableAutoActions: config.enableAutoActions ?? true,
+      pollIntervalMs: config.pollIntervalMs ?? 5e3,
+      now: config.now ?? (() => Math.floor(Date.now() / 1e3))
+    };
+    if (config.events?.onSwapUpdate) this.swapUpdateListeners.add(config.events.onSwapUpdate);
+    if (config.events?.onSwapCompleted) {
+      this.swapCompletedListeners.add(config.events.onSwapCompleted);
+    }
+    if (config.events?.onSwapFailed) this.swapFailedListeners.add(config.events.onSwapFailed);
+    if (config.events?.onActionExecuted) {
+      this.actionExecutedListeners.add(config.events.onActionExecuted);
+    }
+  }
+  /** Wire the money-moving half. Without it the manager only watches. */
+  setCallbacks(callbacks) {
+    this.callbacks = callbacks;
+  }
+  onSwapUpdate(listener) {
+    this.swapUpdateListeners.add(listener);
+    return () => this.swapUpdateListeners.delete(listener);
+  }
+  onSwapCompleted(listener) {
+    this.swapCompletedListeners.add(listener);
+    return () => this.swapCompletedListeners.delete(listener);
+  }
+  onSwapFailed(listener) {
+    this.swapFailedListeners.add(listener);
+    return () => this.swapFailedListeners.delete(listener);
+  }
+  onActionExecuted(listener) {
+    this.actionExecutedListeners.add(listener);
+    return () => this.actionExecutedListeners.delete(listener);
+  }
+  /**
+   * Load records and begin monitoring. Runs one pass immediately — a caller
+   * resuming after a restart may be well past a deadline already — then
+   * every `pollIntervalMs`. Records that are already terminal are kept only
+   * so {@link waitForSwapCompletion} can answer for them.
+   *
+   * Calling it again while running loads the records and returns rather than
+   * re-arming — dropping them silently would strand a funded swap on a
+   * caller's harmless double-start.
+   */
+  async start(swaps = []) {
+    for (const swap of swaps) {
+      if (isRfqSwapTerminal(swap.state)) this.finished.set(swap.rfqId, swap);
+      else this.track(swap);
+    }
+    if (this.running) return;
+    this.running = true;
+    this.subscribe();
+    await this.poll();
+    this.arm();
+  }
+  /**
+   * Stop monitoring and clear the timer. In-flight actions are not
+   * cancellable and run to completion; outstanding
+   * {@link waitForSwapCompletion} promises are left pending, since
+   * stop/start is a pause rather than a cancellation.
+   *
+   * The contract subscription is dropped too — an open stream with nothing
+   * reacting to it is a leak, and {@link start} puts it back. What is NOT
+   * undone is the contract registration: those rows are the wallet's, they
+   * outlive this manager's lifecycle, and dropping them would unwatch a
+   * lockup that is still funded.
+   */
+  async stop() {
+    this.running = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.unsubscribeContracts?.();
+    this.unsubscribeContracts = null;
+  }
+  /** Begin monitoring a swap. Polled immediately when the manager is running,
+   * so a just-funded swap does not wait out a whole interval. */
+  async addSwap(swap) {
+    if (isRfqSwapTerminal(swap.state)) {
+      this.finished.set(swap.rfqId, swap);
+      return;
+    }
+    this.track(swap);
+    if (this.running) await this.pollSwap(swap);
+  }
+  /** Forget a swap entirely, monitored or finished.
+   *
+   * Its contract row is left alone: registration is a wallet-level fact about
+   * a script that may still hold money, and this call says only that THIS
+   * manager stops driving the swap. Retiring the row is reserved for a swap
+   * that reached a terminal state, where the lockup is provably done. */
+  async removeSwap(rfqId) {
+    this.untrack(rfqId);
+    this.finished.delete(rfqId);
+    this.registered.delete(rfqId);
+    const waiting = this.waiters.get(rfqId);
+    if (waiting) {
+      const error = new Error(`swap ${rfqId} was removed from monitoring`);
+      for (const waiter of waiting) waiter.reject(error);
+    }
+    this.waiters.delete(rfqId);
+    this.dirty.delete(rfqId);
+  }
+  /** Every swap still being monitored. */
+  async getPendingSwaps() {
+    return [...this.monitored.values()];
+  }
+  async hasSwap(rfqId) {
+    return this.monitored.has(rfqId);
+  }
+  /** True while an action for this swap holds the per-swap lock. */
+  async isProcessing(rfqId) {
+    return this.inProgress.has(rfqId);
+  }
+  async getStats() {
+    return {
+      isRunning: this.running,
+      monitoredSwaps: this.monitored.size,
+      finishedSwaps: this.finished.size,
+      inProgress: this.inProgress.size,
+      pollIntervalMs: this.config.pollIntervalMs
+    };
+  }
+  /**
+   * Run one monitoring pass over every swap now.
+   *
+   * {@link start} calls this on an interval, but it is public on purpose: a
+   * caller that sleeps its process (a mobile app resuming, a service worker
+   * waking) wants a pass on that event rather than at the next tick. Passes
+   * do not overlap per swap — the in-progress lock makes a concurrent call a
+   * no-op for any swap already being worked on.
+   */
+  async poll() {
+    await Promise.allSettled([...this.monitored.values()].map((swap) => this.pollSwap(swap)));
+  }
+  /**
+   * Resolve once this swap's PAYOUT is decided — which for onchain-send is
+   * the L1 claim, not the end of the record's life: once `claimTxid` is set
+   * the trader has the coins it swapped for, and what remains is the manager
+   * watching the Arkade lockup close. That holds however the record is
+   * labelled afterwards, `needs_counterparty` included. Lightning-send has no
+   * such split and resolves at `settled`/`refunded`, and so does lightning
+   * receive — see {@link isPayoutDecided} for why its own claim txid does not
+   * decide it.
+   *
+   * Rejects only on `failed`. `refunded` resolves: on a send leg a refund is
+   * an outcome the caller asked this manager to drive, not an exception. On a
+   * receive leg it is the swap being lost, which is still an answer and not
+   * an error — read `state`, do not infer success from resolution.
+   */
+  async waitForSwapCompletion(rfqId) {
+    const swap = this.monitored.get(rfqId) ?? this.finished.get(rfqId);
+    if (!swap) throw new Error(`swap ${rfqId} is not monitored`);
+    if (swap.state === "failed") throw new Error(swap.failure ?? `swap ${rfqId} failed`);
+    if (isPayoutDecided(swap)) return outcomeOf(swap);
+    return new Promise((resolve, reject) => {
+      const set = this.waiters.get(rfqId) ?? /* @__PURE__ */ new Set();
+      set.add({ resolve, reject });
+      this.waiters.set(rfqId, set);
+    });
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  track(swap) {
+    this.monitored.set(swap.rfqId, swap);
+    this.byLockupScript.set(import_base11.hex.encode(swap.lockupPkScript), swap);
+  }
+  /** Drops the swap from BOTH indexes. The event index is the one that stops
+   * a late event finding a swap that is gone; `pollSwap`'s own
+   * `monitored` check would also catch it, and deliberately still does —
+   * either alone is sufficient, which is what keeps a future change to one of
+   * them from silently re-driving a cancelled swap. */
+  untrack(rfqId) {
+    const swap = this.monitored.get(rfqId);
+    if (swap) this.byLockupScript.delete(import_base11.hex.encode(swap.lockupPkScript));
+    this.monitored.delete(rfqId);
+    this.refundRefused.delete(rfqId);
+    this.lastClaimError.delete(rfqId);
+    this.claimedOutpoints.delete(rfqId);
+  }
+  /**
+   * Turn the indexer's push into an extra reason to run a pass — and nothing
+   * more.
+   *
+   * **This is deliberately not a source of truth.** An event names a script;
+   * the reaction is to run the ordinary pass for the swap at that script, and
+   * that pass re-reads the lockup through {@link readLockupFate} exactly as
+   * the timer's pass does. So an event that is missed, duplicated, reordered
+   * or outright FORGED can only cost or save latency — it can never change
+   * what this manager believes about a swap, and it can never on its own
+   * cause a claim or a refund. That property is what makes it safe to bolt a
+   * best-effort stream onto a money path, and it must survive any future
+   * change here: the moment an event is BELIEVED rather than merely acted on,
+   * a relay outage becomes a correctness problem instead of a latency one.
+   *
+   * The timer stays armed regardless, and is the failsafe. Every deadline
+   * that moves money — `refundLocktime`, the L1 claim window — is an absolute
+   * timelock that passes whether or not a single event ever arrives.
+   */
+  subscribe() {
+    if (!this.deps.contracts || this.unsubscribeContracts) return;
+    this.unsubscribeContracts = this.deps.contracts.onContractEvent((event) => {
+      if (event.type === "connection_reset") {
+        void this.poll().catch(() => {
+        });
+        return;
+      }
+      const swap = this.byLockupScript.get(event.contractScript);
+      if (!swap) return;
+      void this.pollSwap(swap).catch(() => {
+      });
+    });
+  }
+  /**
+   * Register this swap's lockup with the wallet's contract manager, once.
+   *
+   * The backstop, not the primary site: `requestLightningSend` /
+   * `requestOnchainSend` register before the caller can fund, so this covers
+   * swaps whose records predate that — and costs nothing when it does not,
+   * since `createContract` is first-writer-wins.
+   *
+   * Best-effort by design: a failure here is reported and retried on the next
+   * pass, and never aborts the pass it is part of. Registration buys latency
+   * and puts the lockup in the wallet's contract set; it decides nothing. The
+   * money path below it reads the indexer directly and is gated on timelocks
+   * that a missing contract row has no bearing on, so failing the pass over
+   * this would trade a real deadline for a bookkeeping one.
+   */
+  async ensureRegistered(swap) {
+    const contracts = this.deps.contracts;
+    if (!contracts) return;
+    if (this.registered.has(swap.rfqId)) return;
+    const lockup = swap.lockup;
+    if (!lockup) {
+      try {
+        const [existing] = await contracts.getContracts({
+          script: import_base11.hex.encode(swap.lockupPkScript)
+        });
+        if (existing) {
+          this.registered.set(swap.rfqId, true);
+          return;
+        }
+      } catch (error) {
+        this.emitFailed(swap, error);
+        return;
+      }
+      this.registered.set(swap.rfqId, false);
+      this.emitFailed(
+        swap,
+        new Error(
+          `swap ${swap.rfqId} carries no lockup script and has no contract row, so it cannot be registered \u2014 pass \`lockup\` to subscribe instead of polling`
+        )
+      );
+      return;
+    }
+    const script = import_base11.hex.encode(lockup.script.pkScript);
+    if (script !== import_base11.hex.encode(swap.lockupPkScript)) {
+      this.registered.set(swap.rfqId, false);
+      this.emitFailed(
+        swap,
+        new Error(
+          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${import_base11.hex.encode(swap.lockupPkScript)}`
+        )
+      );
+      return;
+    }
+    try {
+      await registerLockupContract(contracts, lockup.script, lockup.address);
+      this.registered.set(swap.rfqId, true);
+    } catch (error) {
+      this.emitFailed(swap, error);
+    }
+  }
+  /** Stop watching a finished swap's lockup. Retained, not deleted: the row
+   * is what keeps the lockup's own VTXOs annotatable and its history
+   * readable, while `retained` is what drops it from the subscription and
+   * the poll — a settled swap that stayed watched would cost the wallet a
+   * script for its whole life. Best-effort — the swap is over either way. */
+  retireContract(swap) {
+    if (!this.deps.contracts || !this.registered.get(swap.rfqId)) return;
+    void this.deps.contracts.setContractWatchState(import_base11.hex.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
+  }
+  arm() {
+    if (!this.running) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.poll().then(() => this.arm());
+    }, this.config.pollIntervalMs);
+  }
+  async pollSwap(swap) {
+    if (this.inProgress.has(swap.rfqId)) return;
+    if (!this.monitored.has(swap.rfqId)) return;
+    this.inProgress.add(swap.rfqId);
+    try {
+      await this.runPass(swap);
+    } finally {
+      const persisted = this.dirty.has(swap.rfqId) ? await this.save(swap) : true;
+      if (persisted) {
+        this.dirty.delete(swap.rfqId);
+        this.settleWaiters(swap);
+        if (isRfqSwapTerminal(swap.state)) this.finalize(swap);
+      }
+      this.inProgress.delete(swap.rfqId);
+    }
+  }
+  async runPass(swap) {
+    await this.ensureRegistered(swap);
+    let fate;
+    try {
+      fate = await readLockupFate(this.deps.indexer, {
+        swapPkScript: swap.lockupPkScript,
+        paymentHash: swap.paymentHash
+      });
+    } catch {
+      fate = { fate: "unknown" };
+    }
+    if (fate.fate === "claimed" || fate.fate === "returned") {
+      this.setState(swap, fate.fate === "claimed" ? "settled" : "refunded");
+      return;
+    }
+    if (swap.kind === "lightning_receive") return this.driveReceiveClaim(swap);
+    if (swap.kind === "onchain_send" && swap.state !== "claimed") {
+      if (await this.driveOnchain(swap) === "handled") return;
+    }
+    await this.driveArkadeRefund(swap);
+  }
+  /**
+   * The receive leg's whole state machine: claim the solver-funded lockup
+   * while the window is open, and recognise the shapes in which it can be
+   * lost.
+   *
+   * **The window closes at `refundLocktime`, on wall clock, with no margin.**
+   * Both halves of that are deliberate. It closes there because publishing
+   * `P` into the solver's live refund window risks losing the race and
+   * handing over the preimage anyway — the hazard `ONCHAIN_CLAIM_MARGIN_SECONDS`
+   * guards on the L1 side. It takes no margin because the two situations are
+   * not alike: that one budgets for confirmation depth, while this claim is an
+   * offchain spend that lands in seconds. Wall clock is already the
+   * conservative reading — the solver's leaf is a CLTV, which matures against
+   * median-time-past, and MTP trails wall clock — so the real window extends
+   * PAST this deadline rather than ending before it. Every second of margin
+   * subtracted here is a second of live claim window given away for nothing.
+   *
+   * **The trader has no move after it.** Nothing here can take the lockup
+   * back, so once the window shuts the swap is the solver's to resolve and
+   * this manager's job is to watch it happen and then stop.
+   */
+  async driveReceiveClaim(swap) {
+    const now = this.config.now();
+    if (now < swap.refundLocktime) {
+      let vtxos;
+      try {
+        vtxos = await findLockupVtxos(this.deps.indexer, swap.lockupPkScript);
+      } catch (error) {
+        this.emitFailed(swap, error);
+        return;
+      }
+      return this.claimIfFunded(swap, vtxos);
+    }
+    if (now < swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
+      if (swap.claimArkTxid) return;
+      return this.block(
+        swap,
+        "the claim window closed with the lockup unclaimed \u2014 only the solver can act now"
+      );
+    }
+    const failure = this.lastClaimError.get(swap.rfqId);
+    if (failure && !swap.claimArkTxid) {
+      return this.fail(swap, new Error(failure));
+    }
+    this.setState(swap, "refunded");
+  }
+  /**
+   * Claim what the solver funded, once it is enough.
+   *
+   * The value gate here decides WHEN to act. `pushClaim`'s decides whether
+   * `P` is published, and runs with nothing between it and the signature —
+   * the check that matters is the inner one, and this is not a reason to
+   * relax it.
+   */
+  async claimIfFunded(swap, vtxos) {
+    if (vtxos.length === 0) return this.unblock(swap);
+    const partiallyClaimed = swap.claimArkTxid !== void 0;
+    if (partiallyClaimed && !this.hasUnclaimedOutpoint(swap.rfqId, vtxos)) {
+      return;
+    }
+    if (!partiallyClaimed) {
+      if (!Number.isFinite(swap.expectedAmount)) {
+        return this.block(
+          swap,
+          `expectedAmount is not a finite number (${String(swap.expectedAmount)}), so the funded value cannot be checked \u2014 refusing to publish the preimage`
+        );
+      }
+      const locked = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
+      if (!Number.isFinite(locked) || locked < swap.expectedAmount) {
+        return this.block(
+          swap,
+          `lockup holds ${locked} sats, below the agreed ${swap.expectedAmount} \u2014 refusing to publish the preimage`
+        );
+      }
+    }
+    if (!this.callbacks) {
+      return this.block(
+        swap,
+        "no callbacks are wired, so this wallet cannot claim the lockup"
+      );
+    }
+    this.setState(swap, "claimable");
+    if (!this.config.enableAutoActions) return;
+    try {
+      const { arkTxid } = await this.callbacks.claimLockup(swap, vtxos, { partiallyClaimed });
+      this.lastClaimError.delete(swap.rfqId);
+      this.rememberClaimed(swap.rfqId, vtxos);
+      swap.claimArkTxid = arkTxid;
+      this.touch(swap);
+      this.setState(swap, "claimed");
+      this.emitAction(swap, "claimLockup");
+    } catch (error) {
+      this.lastClaimError.set(swap.rfqId, errorMessage(error));
+      this.emitFailed(swap, error);
+    }
+  }
+  /** `handled` ends the pass; `continue` falls through to the refund gate. */
+  async driveOnchain(swap) {
+    if (!this.deps.chain) {
+      this.fail(
+        swap,
+        new Error(
+          "onchain-send swap monitored without a ChainSource \u2014 the L1 fill cannot be seen or claimed"
+        )
+      );
+      return "handled";
+    }
+    let phase;
+    try {
+      phase = await classifyOnchainHtlc(this.deps.chain, {
+        htlc: swap.htlc,
+        minConfirmations: swap.minConfirmations,
+        funding: swap.funding
+      });
+    } catch {
+      return "continue";
+    }
+    if ("utxo" in phase && !swap.funding) {
+      swap.funding = { txid: phase.utxo.txid, vout: phase.utxo.vout };
+      this.touch(swap);
+    }
+    const action = nextOnchainAction({
+      phase,
+      htlcLocktime: swap.htlc.refundLocktime,
+      now: this.config.now()
+    });
+    if (action === "claim" && phase.phase === "claimable") {
+      if (swap.claimTxid) return "continue";
+      this.setOnchainState(swap, "claimable");
+      if (!this.config.enableAutoActions || !this.callbacks) return "handled";
+      try {
+        const { txid } = await this.callbacks.claimOnchain(swap, phase.utxo);
+        swap.claimTxid = txid;
+        this.setOnchainState(swap, "claimed");
+        this.emitAction(swap, "claimOnchain");
+      } catch (error) {
+        this.emitFailed(swap, error);
+      }
+      return "handled";
+    }
+    if (action === "claimed" && phase.phase === "claimed") {
+      if (!swap.claimTxid) {
+        swap.claimTxid = phase.txid;
+        this.touch(swap);
+      }
+      this.setOnchainState(swap, "claimed");
+    }
+    return "continue";
+  }
+  async driveArkadeRefund(swap) {
+    const now = this.config.now();
+    const refusal = await this.probeRefusal(swap);
+    if (refusal) {
+      const claiming = swap.state === "claimable" || swap.state === "claimed";
+      if (now < swap.refundLocktime && claiming) return;
+      return this.block(swap, refusal);
+    }
+    if (this.refundRefused.has(swap.rfqId)) {
+      if (!this.callbacks?.canRefundArkade) return;
+      this.refundRefused.delete(swap.rfqId);
+    }
+    if (now < swap.refundLocktime) return this.unblock(swap);
+    if (!this.config.enableAutoActions || !this.callbacks) {
+      return this.block(
+        swap,
+        this.callbacks ? "automatic actions are disabled, so this wallet will not push the refund" : "no callbacks are wired, so this wallet cannot push the refund"
+      );
+    }
+    this.unblock(swap);
+    try {
+      const pushed = await this.callbacks.refundArkade(swap);
+      if (pushed) {
+        swap.refundArkTxid = pushed.arkTxid;
+        this.touch(swap);
+      }
+      this.setState(swap, "refunded");
+      this.emitAction(swap, "refundArkade");
+    } catch (error) {
+      if (error instanceof RefundNotLocallyPossibleError) {
+        this.refundRefused.add(swap.rfqId);
+        return this.block(swap, error.message);
+      }
+      this.emitFailed(swap, error);
+      if (now >= swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
+        swap.failure = errorMessage(error);
+        this.setState(swap, "failed");
+      }
+    }
+  }
+  /** Whether any of these outputs has never been handed to the claim
+   * callback — the only reason to claim a lockup a second time. */
+  hasUnclaimedOutpoint(rfqId, vtxos) {
+    const claimed = this.claimedOutpoints.get(rfqId);
+    if (!claimed) return true;
+    return vtxos.some((vtxo) => !claimed.has(outpointKey(vtxo)));
+  }
+  rememberClaimed(rfqId, vtxos) {
+    const claimed = this.claimedOutpoints.get(rfqId) ?? /* @__PURE__ */ new Set();
+    for (const vtxo of vtxos) claimed.add(outpointKey(vtxo));
+    this.claimedOutpoints.set(rfqId, claimed);
+  }
+  /**
+   * L1 progress, which past the refund window must not overwrite a refusal.
+   * The two halves are independent — a claimed fill says nothing about
+   * whether this wallet can take the Arkade lockup back — and `claimed` is
+   * re-asserted from chain on every pass, so without this a blocked swap
+   * would flip between the two states forever. The claim itself always runs;
+   * only the label defers, and only once the refund is the live half.
+   */
+  setOnchainState(swap, state) {
+    if (swap.state === "needs_counterparty" && this.config.now() >= swap.refundLocktime) return;
+    this.setState(swap, state);
+  }
+  /** The probe's refusal reason, or `undefined` when a local refund is
+   * possible as far as anyone here can tell. A probe that throws is treated
+   * as a refusal: a capability check that cannot answer is not a yes. */
+  async probeRefusal(swap) {
+    const probe = this.callbacks?.canRefundArkade;
+    if (!probe) return void 0;
+    try {
+      const answer = await probe(swap);
+      return answer.ok ? void 0 : answer.reason;
+    } catch (error) {
+      return errorMessage(error);
+    }
+  }
+  /** Report that no local refund will happen, without ending the swap. */
+  block(swap, reason) {
+    if (swap.blockedReason !== reason) {
+      swap.blockedReason = reason;
+      this.touch(swap);
+    }
+    this.setState(swap, "needs_counterparty");
+  }
+  /** The way back out, taken as soon as the swap becomes actionable again.
+   * Back to what the record can prove, not to `pending` unconditionally: a
+   * swap that already made its claim has a txid for it, and reporting that
+   * swap as `pending` would un-say something true. */
+  unblock(swap) {
+    if (swap.state !== "needs_counterparty") return;
+    this.setState(swap, traderClaimTxid(swap) ? "claimed" : "pending");
+  }
+  touch(swap) {
+    swap.updatedAt = this.config.now();
+    this.dirty.add(swap.rfqId);
+  }
+  setState(swap, state) {
+    if (swap.state === state) return;
+    const previous = swap.state;
+    if (previous === "needs_counterparty") delete swap.blockedReason;
+    swap.state = state;
+    this.touch(swap);
+    notify(this.swapUpdateListeners, (listener) => listener(swap, previous));
+  }
+  /** Terminal failure. The `onSwapFailed` emission is left to
+   * {@link finalize}, so this does not double-report. */
+  fail(swap, error) {
+    swap.failure = error.message;
+    this.setState(swap, "failed");
+  }
+  emitFailed(swap, error) {
+    const wrapped = error instanceof Error ? error : new Error(errorMessage(error));
+    notify(this.swapFailedListeners, (listener) => listener(swap, wrapped));
+  }
+  emitAction(swap, action) {
+    notify(this.actionExecutedListeners, (listener) => listener(swap, action));
+  }
+  /** Whether the record is now persisted — false only when `saveSwap` threw. */
+  async save(swap) {
+    if (!this.callbacks) return true;
+    try {
+      await this.callbacks.saveSwap(swap);
+      return true;
+    } catch (error) {
+      this.emitFailed(swap, error);
+      return false;
+    }
+  }
+  /**
+   * Drop a terminal swap from monitoring and report it exactly once.
+   *
+   * `onSwapCompleted` and `onSwapFailed` are mutually exclusive here, unlike
+   * Boltz's manager, which fires completion for every swap that leaves
+   * monitoring including the failed ones — a listener named "completed" that
+   * also fires on failure is a trap worth not inheriting.
+   */
+  finalize(swap) {
+    if (!this.monitored.has(swap.rfqId)) return;
+    this.untrack(swap.rfqId);
+    this.finished.set(swap.rfqId, swap);
+    this.retireContract(swap);
+    if (swap.state === "failed") {
+      notify(
+        this.swapFailedListeners,
+        (listener) => listener(swap, new Error(swap.failure ?? `swap ${swap.rfqId} failed`))
+      );
+      return;
+    }
+    notify(this.swapCompletedListeners, (listener) => listener(swap));
+  }
+  settleWaiters(swap) {
+    const waiting = this.waiters.get(swap.rfqId);
+    if (!waiting) return;
+    if (swap.state === "failed") {
+      const error = new Error(swap.failure ?? `swap ${swap.rfqId} failed`);
+      for (const waiter of waiting) waiter.reject(error);
+    } else if (isPayoutDecided(swap)) {
+      const outcome = outcomeOf(swap);
+      for (const waiter of waiting) waiter.resolve(outcome);
+    } else {
+      return;
+    }
+    this.waiters.delete(swap.rfqId);
+  }
+};
+var traderClaimTxid = (swap) => {
+  switch (swap.kind) {
+    case "onchain_send":
+      return swap.claimTxid;
+    case "lightning_receive":
+      return swap.claimArkTxid;
+    default:
+      return void 0;
+  }
+};
+var isPayoutDecided = (swap) => swap.state === "settled" || swap.state === "refunded" || swap.kind === "onchain_send" && swap.claimTxid !== void 0;
+var outcomeOf = (swap) => {
+  const lostReceive = swap.kind === "lightning_receive" && swap.state === "refunded";
+  return {
+    state: swap.state,
+    txid: lostReceive ? swap.refundArkTxid : traderClaimTxid(swap) ?? swap.refundArkTxid
+  };
+};
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARKADE_ASSET,
+  ARKADE_BTC,
+  AddressMismatch,
+  BTC_ASSET_ID,
+  InMemoryAssetSwapRepository,
+  IndexedDbAssetSwapRepository,
+  LIGHTNING_BTC,
+  LIGHTNING_RECEIVE_PAIR,
+  LIGHTNING_SEND_PAIR,
+  LockupAmountMismatchError,
+  LockupNeedsRecoveryError,
+  LockupRegistrationFailed,
+  MAX_MIN_CONFIRMATIONS,
+  MIN_CLAIM_WINDOW_SECONDS,
+  MIN_HEADROOM_SECONDS,
+  OFFER_PACKET_TYPE,
+  ONCHAIN_BTC,
+  ONCHAIN_CLAIM_MARGIN_SECONDS,
+  ONCHAIN_DUST_SATS,
+  ONCHAIN_ORDER_MARGIN_SECONDS,
+  ONCHAIN_RECEIVE_PAIR,
+  ONCHAIN_SECONDS_PER_BLOCK,
+  ONCHAIN_SEND_PAIR,
+  QUOTE_OPTIONS,
+  REFUND_MTP_LAG_SECONDS,
+  RFQ_PREIMAGE_TAG,
+  RFQ_RESOLVED_STATES,
+  RFQ_SWAP_TERMINAL_STATES,
+  RFQ_TERMINAL_STATES,
+  RefundNotLocallyPossibleError,
+  RfqSwapManager,
+  SWAP_LOCKUP_CONTRACT_KIND,
+  SWAP_LOCKUP_CONTRACT_LABEL,
+  SWAP_LOCKUP_CONTRACT_TYPE,
+  SwapRefusal,
+  addAssetSwap,
+  adoptSwapDescriptor,
+  arkadeSwapRequest,
+  assertFundable,
+  assertReceivable,
+  awaitLockupFunding,
+  awaitOnchainFill,
+  awaitRfqResolution,
+  buildHtlcClaim,
+  buildHtlcRefund,
+  buildPreimageMessage,
+  cancelOffer,
+  claimOnchainFill,
+  claimReceiveLockup,
+  classifyDepositSpend,
+  classifyOnchainHtlc,
+  classifySpend,
+  createOffer,
+  decodeOffer,
+  deriveLightningReceive,
+  deriveOnchainReceive,
+  deriveOnchainSend,
+  derivePreimage,
+  deriveSwapSecrets,
+  discoverMarkets,
+  encodeOffer,
+  extractPreimage,
+  findLockupVtxos,
+  findMarket,
+  getAssetSwaps,
+  getAssetSwapsOrThrow,
+  httpTransport,
+  isDeterministicSigner,
+  isRfqSwapTerminal,
+  isRfqTerminal,
+  lightningReceiveRequest,
+  lightningSendRequest,
+  lightningSendVtxoScript,
+  makeCachedFeedFetch,
+  newPreimage,
+  newRfqId,
+  nextOnchainAction,
+  offerTermsFromQuote,
+  offerVtxoScript,
+  onchainHtlcScript,
+  onchainReceiveRequest,
+  onchainSendRequest,
+  paymentHashOf,
+  preimageForRfqSecrets,
+  pushClaim,
+  pushRefundWithoutReceiver,
+  randomSwapSecrets,
+  readLockupFate,
+  receiveVtxoScript,
+  refundIfUnresolved,
+  registerLockupContract,
+  relayTransport,
+  requestLightningReceive,
+  requestLightningSend,
+  requestOnchainReceive,
+  requestOnchainSend,
+  restoreAssetSwaps,
+  retireSettledOfferContracts,
+  rfqPair,
+  rfqSecretsOfRecord,
+  rfqSecretsToRecord,
+  sealClaimPacket,
+  senderIdentityForRfqSecrets,
+  senderIdentityForSwapRecord,
+  senderPubkeyForRfqSecrets,
+  spendTxidsOf,
+  spendUpdate,
+  swapPrograms,
+  unilateralClaimDelay,
+  unilateralRefundDelay,
+  unilateralRefundWithoutReceiverDelay,
+  updateAssetSwap,
+  updateAssetSwapBestEffort,
+  validatePlan,
+  verifyLockupAddress,
+  verifyReceiveInvoice,
+  watchOfferSwaps
+});