@arkade-os/swap 0.0.1

package/dist/index.js

@@ -0,0 +1,2242 @@
+import {
+  ARKADE_ASSET,
+  ARKADE_BTC,
+  AddressMismatch,
+  LIGHTNING_BTC,
+  LIGHTNING_RECEIVE_PAIR,
+  LIGHTNING_SEND_PAIR,
+  LockupRegistrationFailed,
+  MAX_MIN_CONFIRMATIONS,
+  MIN_CLAIM_WINDOW_SECONDS,
+  MIN_HEADROOM_SECONDS,
+  ONCHAIN_BTC,
+  ONCHAIN_CLAIM_MARGIN_SECONDS,
+  ONCHAIN_DUST_SATS,
+  ONCHAIN_ORDER_MARGIN_SECONDS,
+  ONCHAIN_RECEIVE_PAIR,
+  ONCHAIN_SECONDS_PER_BLOCK,
+  ONCHAIN_SEND_PAIR,
+  RFQ_PREIMAGE_TAG,
+  RFQ_TERMINAL_STATES,
+  RefundNotLocallyPossibleError,
+  SWAP_LOCKUP_CONTRACT_KIND,
+  SWAP_LOCKUP_CONTRACT_LABEL,
+  SWAP_LOCKUP_CONTRACT_TYPE,
+  SwapRefusal,
+  adoptSwapDescriptor,
+  arkadeSwapRequest,
+  assertFundable,
+  assertReceivable,
+  awaitOnchainFill,
+  buildHtlcClaim,
+  buildHtlcRefund,
+  buildPreimageMessage,
+  claimOnchainFill,
+  classifyOnchainHtlc,
+  deriveLightningReceive,
+  deriveOnchainReceive,
+  deriveOnchainSend,
+  derivePreimage,
+  deriveSwapSecrets,
+  extractPreimage,
+  httpTransport,
+  isDeterministicSigner,
+  lightningReceiveRequest,
+  lightningSendRequest,
+  lightningSendVtxoScript,
+  newPreimage,
+  newRfqId,
+  offerTermsFromQuote,
+  onchainHtlcScript,
+  onchainReceiveRequest,
+  onchainSendRequest,
+  paymentHashOf,
+  preimageForRfqSecrets,
+  randomSwapSecrets,
+  receiveVtxoScript,
+  registerLockupContract,
+  relayTransport,
+  requestLightningReceive,
+  requestLightningSend,
+  requestOnchainReceive,
+  requestOnchainSend,
+  rfqPair,
+  rfqSecretsOfRecord,
+  rfqSecretsToRecord,
+  sealClaimPacket,
+  senderIdentityForRfqSecrets,
+  senderIdentityForSwapRecord,
+  senderPubkeyForRfqSecrets,
+  unilateralClaimDelay,
+  unilateralRefundDelay,
+  unilateralRefundWithoutReceiverDelay,
+  verifyLockupAddress,
+  verifyReceiveInvoice
+} from "./chunk-C5P7R7JT.js";
+
+// src/offer.ts
+import { hex } from "@scure/base";
+import { concatBytes } from "@scure/btc-signer/utils.js";
+import {
+  ArkAddress,
+  RestArkProvider,
+  RestIndexerProvider,
+  arkade,
+  asset,
+  getNetwork
+} from "@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: arkade.parseArtifact(swap_want_asset_program_default),
+  wantBtc: 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 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 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 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: asset.AssetId.fromBytes(fields.wantAsset) },
+    ...fields.offerAsset && { offerAsset: 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 arkade.Arkade.connect({
+    arkade: new RestArkProvider(arkServerUrl),
+    indexer: new 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: getNetwork(network),
+    contractManager
+  });
+  const contract = new arkade.ArkadeContract(client, program, args, keys);
+  if (hex.encode(contract.pkScript) !== 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, 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 RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getAddress(),
+    wallet.identity.xOnlyPublicKey()
+  ]);
+  const serverPubKey = xOnly(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: 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: 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(getNetwork(info.network).hrp, serverPubKey).encode(),
+    swapPkScript: script.pkScript
+  };
+}
+async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
+  const { repository, fundingTxid, swapAddress } = opts;
+  const offer = decodeOffer(hex.decode(offerHex));
+  const contractManager = await wallet.getContractManager();
+  const client = await arkade.Arkade.connect({
+    arkade: new RestArkProvider(arkServerUrl),
+    indexer: new 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 ? ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, serverKey);
+  const rebuilt = new arkade.ArkadeProgramScript(program, args, keys);
+  if (hex.encode(rebuilt.pkScript) !== 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 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 = 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, hex.encode(offer.swapPkScript));
+    }
+  }
+  return txid;
+}
+
+// src/markets.ts
+import {
+  bestMarket,
+  discover,
+  isNetwork,
+  sideLimits
+} from "@arkade-os/solver-discovery";
+import { isSubdust } from "@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 || !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 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 = bestMarket(markets, { baseId: fromId, quoteId: toId, wantSide: "quote" });
+  if (givingBase) return { market: givingBase, give: "base" };
+  return {
+    market: 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 = 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 (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
+import { closeDatabase, openDatabase } from "@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 ??= 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 closeDatabase(this.dbName);
+    this.dbPromise = null;
+  }
+};
+
+// src/restore.ts
+import { base64, hex as hex2 } from "@scure/base";
+import {
+  Extension,
+  Transaction,
+  scriptFromTapLeafScript
+} from "@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 = Transaction.fromPSBT(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 (hex2.encode(script.pkScript) !== hex2.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 (hex2.encode(input.txid) !== deposit.txid) continue;
+    for (const leaf of input.tapLeafScript ?? []) {
+      const spent = hex2.encode(scriptFromTapLeafScript(leaf));
+      if (leaves.cancel && spent === hex2.encode(leaves.cancel)) return "cancelled";
+      if (leaves.fulfill && spent === hex2.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 = Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
+      if (!packet) continue;
+      const payload = packet.serialize();
+      found.push({
+        fundingTx,
+        offer: decodeOffer(payload),
+        offerHex: hex2.encode(payload)
+      });
+    } catch {
+    }
+  }
+  if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
+  const scripts = [...new Set(found.map((f) => hex2.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(
+      `${hex2.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 = hex2.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
+import { base64 as base642, hex as hex3 } from "@scure/base";
+import {
+  ArkAddress as ArkAddress2,
+  RestIndexerProvider as RestIndexerProvider3,
+  Transaction as Transaction2
+} from "@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 = ArkAddress2.decode(await wallet.getAddress()).serverPubKey;
+  const indexer = new RestIndexerProvider3(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(hex3.decode(swap.offerHex)),
+        serverPubkey,
+        txs.map((psbt) => Transaction2.fromPSBT(base642.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/claim.ts
+import { hex as hex5 } from "@scure/base";
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import {
+  CSVMultisigTapscript as CSVMultisigTapscript2,
+  claimWithPreimageIdentity,
+  signAndSubmitOffchainTx
+} from "@arkade-os/sdk";
+
+// src/refund.ts
+import { base64 as base643, hex as hex4 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import {
+  CSVMultisigTapscript,
+  ConditionWitness,
+  Transaction as Transaction3,
+  assertSubmittedArkTxid,
+  buildOffchainTx,
+  getArkPsbtFields,
+  matchServerCheckpoints
+} from "@arkade-os/sdk";
+var sleep = (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 sleep(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 = [hex4.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) => hex4.encode(sha256(candidate)) === paymentHash;
+var candidateWitnessItems = (tx, inputIndex) => [
+  ...getArkPsbtFields(tx, inputIndex, ConditionWitness).flat(),
+  ...tx.getInput(inputIndex).finalScriptWitness ?? []
+];
+async function readLockupFate(indexer, input) {
+  const { vtxos } = await indexer.getVtxos({ scripts: [hex4.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 = Transaction3.fromPSBT(base643.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 = hex4.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 = CSVMultisigTapscript.decode(hex4.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 } = 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(
+    base643.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => base643.encode(c.toPSBT()))
+  );
+  assertSubmittedArkTxid(submitted, signedArkTx, "refundWithoutReceiver");
+  const matched = matchServerCheckpoints(
+    submitted.signedCheckpointTxs,
+    checkpoints,
+    "refundWithoutReceiver"
+  );
+  const finalCheckpoints = await Promise.all(
+    matched.map(
+      async ({ server }) => base643.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 sleep(pollMs);
+  }
+}
+
+// src/claim.ts
+var sleep2 = (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 (hex5.encode(ripemd160(sha2562(input.preimage))) !== hex5.encode(committed)) {
+    throw new Error("preimage does not match the covenant's payment hash");
+  }
+  const info = await ark.getInfo();
+  let serverUnrollScript;
+  try {
+    serverUnrollScript = CSVMultisigTapscript2.decode(hex5.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 signAndSubmitOffchainTx({
+    identity: 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 sleep2(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
+import { hex as hex6 } from "@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(hex6.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(hex6.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: hex6.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 = hex6.encode(lockup.script.pkScript);
+    if (script !== hex6.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 ${hex6.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(hex6.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}`;
+export {
+  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
+};