@arkade-os/swap 0.0.14 → 0.0.16

package/dist/index.cjs

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   ARKADE_ASSET: () => ARKADE_ASSET,
   ARKADE_BTC: () => ARKADE_BTC,
+  ASSET_CARRIER_SATS: () => ASSET_CARRIER_SATS,
   AddressMismatch: () => AddressMismatch,
   BTC_ASSET_ID: () => BTC_ASSET_ID,
   CROSS_ASSET_RAIL: () => CROSS_ASSET_RAIL,
@@ -46,6 +47,7 @@ __export(index_exports, {
   LockupContractMissing: () => LockupContractMissing,
   LockupNeedsRecoveryError: () => LockupNeedsRecoveryError,
   LockupRegistrationFailed: () => LockupRegistrationFailed,
+  MARKET_CORRIDORS: () => MARKET_CORRIDORS,
   MAX_MIN_CONFIRMATIONS: () => MAX_MIN_CONFIRMATIONS,
   MIN_CLAIM_WINDOW_SECONDS: () => MIN_CLAIM_WINDOW_SECONDS,
   MIN_HEADROOM_SECONDS: () => MIN_HEADROOM_SECONDS,
@@ -60,6 +62,7 @@ __export(index_exports, {
   PreimageNotRecoverableError: () => PreimageNotRecoverableError,
   QUOTE_OPTIONS: () => QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS: () => REFUND_MTP_LAG_SECONDS,
+  RFQ_REFUSAL_ERROR_CODES: () => RFQ_REFUSAL_ERROR_CODES,
   RFQ_RESOLVED_STATES: () => RFQ_RESOLVED_STATES,
   RFQ_SWAP_RETENTION_SECONDS: () => RFQ_SWAP_RETENTION_SECONDS,
   RFQ_SWAP_TERMINAL_STATES: () => RFQ_SWAP_TERMINAL_STATES,
@@ -103,11 +106,14 @@ __export(index_exports, {
   discoverMarkets: () => discoverMarkets,
   encodeOffer: () => encodeOffer,
   extractPreimage: () => extractPreimage,
+  fillOffer: () => fillOffer,
   findLockupVtxos: () => findLockupVtxos,
   findMarket: () => findMarket,
   getAssetSwaps: () => getAssetSwaps,
   getAssetSwapsOrThrow: () => getAssetSwapsOrThrow,
   httpTransport: () => httpTransport,
+  isRfqMarket: () => isRfqMarket,
+  isRfqRefusalErrorCode: () => isRfqRefusalErrorCode,
   isRfqSwapTerminal: () => isRfqSwapTerminal,
   isRfqTerminal: () => isRfqTerminal,
   l1ScriptForAddress: () => l1ScriptForAddress,
@@ -116,6 +122,9 @@ __export(index_exports, {
   lightningSendVtxoScript: () => lightningSendVtxoScript,
   lockupContractParams: () => lockupContractParams,
   makeCachedFeedFetch: () => makeCachedFeedFetch,
+  marketAssetId: () => marketAssetId,
+  marketCorridor: () => marketCorridor,
+  marketPairLabel: () => marketPairLabel,
   newPreimage: () => newPreimage,
   newRfqId: () => newRfqId,
   nextOnchainAction: () => nextOnchainAction,
@@ -133,13 +142,16 @@ __export(index_exports, {
   rebuildRfqSwap: () => rebuildRfqSwap,
   receiveVtxoScript: () => receiveVtxoScript,
   refundIfUnresolved: () => refundIfUnresolved,
+  registerAssetSwapRestore: () => registerAssetSwapRestore,
   registerLockupContract: () => registerLockupContract,
   relayTransport: () => relayTransport,
   requestLightningReceive: () => requestLightningReceive,
   requestLightningSend: () => requestLightningSend,
   requestOnchainReceive: () => requestOnchainReceive,
   requestOnchainSend: () => requestOnchainSend,
+  restoreAssetSwapRepository: () => restoreAssetSwapRepository,
   restoreAssetSwaps: () => restoreAssetSwaps,
+  restoreOfferCoverage: () => restoreOfferCoverage,
   retireSettledOfferContracts: () => retireSettledOfferContracts,
   revealClaimPacket: () => revealClaimPacket,
   revealFieldsFromScript: () => revealFieldsFromScript,
@@ -283,10 +295,10 @@ function addressOutstanding(swaps, script) {
   }
   return true;
 }
-async function promoteOfferContract(manager, script) {
+async function promoteOfferContract(manager, script, issued = Date.now()) {
   await serialize(script, async () => {
     await manager.setContractWatchState(script, "watched");
-    issuedAt.set(script, Date.now());
+    issuedAt.set(script, issued);
   });
 }
 async function retireOfferContract(manager, swaps, script) {
@@ -492,7 +504,7 @@ function u64(name, value) {
   if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
     throw new Error(`${name} does not fit the offer wire format (u64)`);
   }
-  const out = new Uint8Array(FIELDS.wantAmount.width);
+  const out = new Uint8Array(8);
   new DataView(out.buffer).setBigUint64(0, value, false);
   return out;
 }
@@ -627,10 +639,9 @@ function decodeExitDelay(value) {
 }
 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_sdk2.arkade.Arkade.connect({
+async function registerOfferContract(wallet, arkServerUrl, network, binding, serverPubkey, expectedPkScript, opts = {}) {
+  const contractManager = opts.contractManager ?? await wallet.getContractManager();
+  const client = opts.client ?? await import_sdk2.arkade.Arkade.connect({
     arkade: new import_sdk2.RestArkProvider(arkServerUrl),
     indexer: new import_sdk2.RestIndexerProvider(arkServerUrl),
     identity: wallet.identity,
@@ -640,15 +651,66 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
     network: (0, import_sdk2.getNetwork)(network),
     contractManager
   });
+  await contractManager.createContract(
+    offerContractParams(client, binding, serverPubkey, expectedPkScript)
+  );
+  await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript), opts.issued);
+}
+function offerContractParams(client, binding, serverPubkey, expectedPkScript) {
+  const { program, args, keys } = swapProgramBinding(binding, serverPubkey);
   const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
   if (import_base2.hex.encode(contract.pkScript) !== import_base2.hex.encode(expectedPkScript)) {
     throw new Error("derived covenant does not match the offer's swapPkScript");
   }
-  await contract.register({
+  return {
+    ...contract.toContractParams(),
     label: OFFER_CONTRACT_LABEL,
     metadata: { genericallySpendable: false, kind: OFFER_CONTRACT_KIND }
+  };
+}
+async function restoreOfferCoverage(wallet, arkServerUrl, swaps) {
+  const live = swaps.filter((s) => !RETIRABLE.includes(s.status));
+  if (live.length === 0) return;
+  const arkProvider = new import_sdk2.RestArkProvider(arkServerUrl);
+  const info = await arkProvider.getInfo();
+  const serverPubKey = import_base2.hex.decode((0, import_sdk2.toXOnlySignerHex)(info.signerPubkey));
+  const contractManager = await wallet.getContractManager();
+  const client = await import_sdk2.arkade.Arkade.connect({
+    arkade: arkProvider,
+    indexer: new import_sdk2.RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    network: (0, import_sdk2.getNetwork)(info.network),
+    contractManager
   });
-  await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript));
+  const done = /* @__PURE__ */ new Set();
+  const covenants = [];
+  for (const swap of live) {
+    if (done.has(swap.swapPkScript)) continue;
+    done.add(swap.swapPkScript);
+    try {
+      const { swapPkScript: _, ...binding } = decodeOffer(import_base2.hex.decode(swap.offerHex));
+      covenants.push({
+        script: swap.swapPkScript,
+        issued: swap.createdAt,
+        params: offerContractParams(
+          client,
+          binding,
+          serverPubKey,
+          import_base2.hex.decode(swap.swapPkScript)
+        )
+      });
+    } catch (err) {
+      console.warn(`[swap] could not restore coverage for ${swap.swapPkScript}`, err);
+    }
+  }
+  if (covenants.length === 0) return;
+  const paramsList = covenants.map((c) => c.params);
+  if (contractManager.createContracts) {
+    await contractManager.createContracts(paramsList);
+  } else {
+    for (const params of paramsList) await contractManager.createContract(params);
+  }
+  for (const c of covenants) await promoteOfferContract(contractManager, c.script, c.issued);
 }
 function serverExitDelay(delay) {
   if (typeof delay !== "bigint" || delay <= BigInt(0)) {
@@ -761,10 +823,170 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   }
   return txid;
 }
+var ASSET_CARRIER_SATS = BigInt(import_sdk2.ASSET_CARRIER_SATS);
+async function fillOffer(wallet, arkServerUrl, offerHex, opts) {
+  const {
+    fund,
+    payoutScript,
+    fundingTxid,
+    swapAddress,
+    assetCarrierSats = ASSET_CARRIER_SATS,
+    emulator,
+    emulatorPubkey
+  } = opts;
+  const offer = decodeOffer(import_base2.hex.decode(offerHex));
+  const wantedAssetId = offer.wantAsset?.toString();
+  if (fund.length === 0) {
+    throw new Error("fillOffer needs coins to pay wantAmount with \u2014 `fund` is empty");
+  }
+  if (wantedAssetId !== void 0) {
+    const supplied = fund.reduce(
+      (sum, coin) => sum + amountOfAsset(coin.assets, wantedAssetId),
+      BigInt(0)
+    );
+    if (supplied < offer.wantAmount) {
+      throw new Error(
+        `fillOffer needs ${offer.wantAmount} of ${wantedAssetId} to pay the maker, but \`fund\` declares ${supplied} \u2014 pass coins carrying it, and declare their assets`
+      );
+    }
+  }
+  const contractManager = await wallet.getContractManager();
+  const client = await import_sdk2.arkade.Arkade.connect({
+    arkade: new import_sdk2.RestArkProvider(arkServerUrl),
+    indexer: new import_sdk2.RestIndexerProvider(arkServerUrl),
+    identity: wallet.identity,
+    contractManager,
+    // `fulfill` is a covenant path, so the emulator executes the arkade
+    // script and finalizes with arkd. Without it the spend is built and then
+    // refused at submission — there is no default to fall back on.
+    emulator: typeof emulator === "string" ? new import_sdk2.RestEmulatorProvider(emulator) : emulator,
+    // Only reached for the client's own emulatorKey, which this fill never
+    // derives against — the offer's own key is bound below. It still has to
+    // resolve, and on a network with no pinned key it throws without this.
+    ...emulatorPubkey ? { emulatorPubkey } : {}
+  });
+  const serverKey = swapAddress ? import_sdk2.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, serverKey);
+  const rebuilt = new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
+  if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.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_sdk2.arkade.ArkadeContract(client, program, args, keys);
+  const [vtxos, takerAddress] = 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");
+  if (offer.offerAsset) {
+    const offered = offer.offerAsset.toString();
+    const deposited = amountOfAsset(vtxo.assets, offered);
+    if (deposited <= BigInt(0)) {
+      throw new Error(
+        `the deposit at the swap address carries no ${offered}, which this offer sells \u2014 filling it would pay wantAmount for nothing. The indexer may be behind, or the offer may not be backed by what it advertises`
+      );
+    }
+  }
+  const payout = payoutScript ?? import_sdk2.ArkAddress.decode(takerAddress).pkScript;
+  const makerSats = wantedAssetId === void 0 ? offer.wantAmount : assetCarrierSats;
+  const fill = contract.functions.fulfill().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).fund(fund).to(offer.makerPkScript, makerSats).change(payout);
+  const held = /* @__PURE__ */ new Map();
+  const hold = (vin, assets) => {
+    for (const a of assets ?? []) {
+      const amount = BigInt(a.amount);
+      if (amount <= BigInt(0)) continue;
+      held.set(a.assetId, [...held.get(a.assetId) ?? [], { vin, amount }]);
+    }
+  };
+  hold(0, vtxo.assets);
+  fund.forEach((coin, i) => hold(i + 1, coin.assets));
+  const outputsSum = makerSats;
+  const inputsSum = fund.reduce((s, c) => s + BigInt(c.value), BigInt(vtxo.value));
+  const hasPayoutOutput = inputsSum > outputsSum;
+  const emitWanted = () => {
+    if (wantedAssetId === void 0) return;
+    const supplying = held.get(wantedAssetId) ?? [];
+    const supplied = supplying.reduce((s, i) => s + i.amount, BigInt(0));
+    const outputs = [{ vout: 0, amount: offer.wantAmount }];
+    const surplus = supplied - offer.wantAmount;
+    if (surplus > BigInt(0)) {
+      if (!hasPayoutOutput) {
+        throw new Error(
+          `fillOffer has ${surplus} of ${wantedAssetId} to return but no payout output \u2014 fund with more sats than the maker's output takes`
+        );
+      }
+      outputs.push({ vout: 1, amount: surplus });
+    }
+    fill.withAsset({ assetId: wantedAssetId, inputs: supplying, outputs });
+    held.delete(wantedAssetId);
+  };
+  emitWanted();
+  for (const [assetId, inputs] of held) {
+    const amount = inputs.reduce((s, i) => s + i.amount, BigInt(0));
+    if (!hasPayoutOutput) {
+      throw new Error(
+        `fillOffer has ${amount} of ${assetId} to return but no payout output \u2014 fund with more sats than the maker's output takes`
+      );
+    }
+    fill.withAsset({ assetId, inputs, outputs: [{ vout: 1, amount }] });
+  }
+  const { txid } = await fill.send();
+  return txid;
+}
+var amountOfAsset = (assets, assetId) => {
+  let total = BigInt(0);
+  for (const a of assets ?? []) {
+    if (a.assetId === assetId) total += BigInt(a.amount);
+  }
+  return total;
+};
 
 // src/markets.ts
 var import_solver_discovery = require("@arkade-os/solver-discovery");
 var import_sdk3 = require("@arkade-os/sdk");
+
+// src/marketShape.ts
+var MARKET_CORRIDORS = ["arkade", "bolt11", "bitcoin", "eip155"];
+var LEGACY_CORRIDORS = {
+  arkade: "arkade",
+  lightning: "bolt11",
+  onchain: "bitcoin",
+  eip155: "eip155"
+};
+var assetOf = (market, side) => side === "base" ? market.base_asset : market.quote_asset;
+var marketAssetId = (market, side) => {
+  const asset3 = assetOf(market, side);
+  if (typeof asset3?.caip19_id === "string") return asset3.caip19_id;
+  return typeof asset3?.id === "string" ? asset3.id : void 0;
+};
+var chainNamespaceOf = (id) => {
+  if (id === void 0) return void 0;
+  const slash = id.indexOf("/");
+  const colon = id.indexOf(":");
+  return slash === -1 || colon === -1 || colon > slash ? void 0 : id.slice(0, colon);
+};
+var marketCorridor = (market, side) => {
+  const namespace = chainNamespaceOf(marketAssetId(market, side));
+  if (namespace !== void 0) {
+    return MARKET_CORRIDORS.includes(namespace) ? namespace : "arkade";
+  }
+  const legacy = side === "base" ? market.base_corridor : market.quote_corridor;
+  return typeof legacy === "string" ? LEGACY_CORRIDORS[legacy] ?? "arkade" : "arkade";
+};
+var isRfqMarket = (market) => marketCorridor(market, "base") !== "arkade" || marketCorridor(market, "quote") !== "arkade";
+var sideLabel = (market, side) => {
+  const ticker = assetOf(market, side)?.ticker;
+  const label = typeof ticker === "string" && ticker.length > 0 ? ticker : "?";
+  const corridor = marketCorridor(market, side);
+  return corridor === "arkade" ? label : `${corridor}:${label}`;
+};
+var marketPairLabel = (market) => `${sideLabel(market, "base")}/${sideLabel(market, "quote")}`;
+
+// src/markets.ts
 var QUOTE_OPTIONS = { safetyBps: 0 };
 var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
   const cache = /* @__PURE__ */ new Map();
@@ -813,14 +1035,17 @@ var makeCachedFeedFetch = (ttlMs = 3e4, fetchImpl = fetch) => {
 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";
+  if (!market) return false;
+  return 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;
+    const markets = entry.markets.filter(isMarketShaped);
+    if (entry.markets.length > 0 && markets.length === 0) return void 0;
+    return { ...entry, markets };
   } catch {
     return void 0;
   }
@@ -861,10 +1086,33 @@ var discoverMarkets = async (options) => {
 };
 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" });
+  const resolveMarketId = (id) => {
+    for (const market of markets) {
+      for (const side of ["base", "quote"]) {
+        const asset3 = side === "base" ? market.base_asset : market.quote_asset;
+        if (asset3.id === id) return id;
+        const canonical = marketAssetId(market, side) ?? "";
+        const matchesBtc = id === BTC_ASSET_ID && /^arkade:[^/]+\/slip44:(?:0|1)$/.test(canonical);
+        const matchesAsset = /^[0-9a-f]{68}$/.test(id) && canonical.endsWith(`/asset:${id}`);
+        if ((matchesBtc || matchesAsset) && typeof asset3.id === "string") return asset3.id;
+      }
+    }
+    return id;
+  };
+  const resolvedFrom = resolveMarketId(fromId);
+  const resolvedTo = resolveMarketId(toId);
+  const givingBase = (0, import_solver_discovery.bestMarket)(markets, {
+    baseId: resolvedFrom,
+    quoteId: resolvedTo,
+    wantSide: "quote"
+  });
   if (givingBase) return { market: givingBase, give: "base" };
   return {
-    market: (0, import_solver_discovery.bestMarket)(markets, { baseId: toId, quoteId: fromId, wantSide: "base" }),
+    market: (0, import_solver_discovery.bestMarket)(markets, {
+      baseId: resolvedTo,
+      quoteId: resolvedFrom,
+      wantSide: "base"
+    }),
     give: "quote"
   };
 };
@@ -1035,8 +1283,316 @@ var IndexedDbAssetSwapRepository = class {
   }
 };
 
+// src/restore.ts
+var import_base3 = require("@scure/base");
+var import_sdk5 = 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_sdk5.Transaction.fromPSBT(import_base3.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_base3.hex.encode(script.pkScript) !== import_base3.hex.encode(offer.swapPkScript)) return "indeterminate";
+    leaves = {
+      // both routes that hand the deposit back; `exit` is absent on an
+      // offer that carries no exit closure, and drops out here
+      returned: ["cancel", "exit"].map((name) => script.functionByName(name)?.leafScript).filter((leaf) => leaf !== void 0),
+      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_base3.hex.encode(input.txid) !== deposit.txid) continue;
+    for (const leaf of input.tapLeafScript ?? []) {
+      const spent = import_base3.hex.encode((0, import_sdk5.scriptFromTapLeafScript)(leaf));
+      if (leaves.returned.some((back) => spent === import_base3.hex.encode(back))) return "cancelled";
+      if (leaves.fulfill && spent === import_base3.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(), reopen = [] } = opts;
+  const reopened = [];
+  for (const swap of reopen) {
+    try {
+      reopened.push({
+        fundingTx: { type: "sent", redeemTxid: swap.fundingTxid },
+        offer: decodeOffer(import_base3.hex.decode(swap.offerHex)),
+        offerHex: swap.offerHex,
+        existing: swap
+      });
+    } catch {
+    }
+  }
+  const reopenedTxids = new Set(reopened.map((f) => f.fundingTx.redeemTxid));
+  const candidates = unscannedSwapCandidates(txs, existingIds, scanned).filter(
+    (tx) => !reopenedTxids.has(tx.redeemTxid)
+  );
+  if (candidates.length === 0 && reopened.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 = [...reopened];
+  for (const [txid, parsed] of parsedByTxid) {
+    const fundingTx = byTxid.get(txid);
+    if (!fundingTx) continue;
+    fetchedTxids.push(txid);
+    try {
+      const packet = import_sdk5.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
+      if (!packet) continue;
+      const payload = packet.serialize();
+      found.push({
+        fundingTx,
+        offer: decodeOffer(payload),
+        offerHex: import_base3.hex.encode(payload)
+      });
+    } catch {
+    }
+  }
+  if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
+  const scripts = [...new Set(found.map((f) => import_base3.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_base3.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, existing } of found) {
+    const swapPkScript = import_base3.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;
+    }
+    const completion = status === "fulfilled" && spentTxid && txByAnyId.get(spentTxid)?.createdAt ? { completedAt: txByAnyId.get(spentTxid).createdAt * 1e3 } : {};
+    if (existing) {
+      if (status === "pending") continue;
+      restored.push({ ...existing, status, spentTxid, ...completion });
+      continue;
+    }
+    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(),
+      ...completion
+    });
+  }
+  return { restored, scannedTxids: fetchedTxids.filter((id) => !unresolved.has(id)) };
+}
+
+// src/restoreRepository.ts
+var isOpen = (swap) => swap.status === "pending" || swap.status === "cancelling";
+var isOfferSwap = (swap) => typeof swap.offerHex === "string";
+var restoreCoverage = async (wallet, arkServerUrl, swaps) => {
+  const offers = swaps.filter(isOfferSwap);
+  if (offers.length > 0) await restoreOfferCoverage(wallet, arkServerUrl, offers);
+};
+var aborted = (swaps) => ({
+  swaps,
+  changes: [],
+  scannedTxids: [],
+  aborted: true
+});
+async function restoreAssetSwapRepository(opts) {
+  const { wallet, arkServerUrl, indexer, repository, txs, serverPubkey, prepareNew, signal } = opts;
+  const [existing, scanned] = await Promise.all([
+    getAssetSwapsOrThrow(repository),
+    repository.getScannedTxids()
+  ]);
+  if (signal?.aborted) return aborted(existing);
+  let scan;
+  try {
+    scan = await restoreAssetSwaps(indexer, txs, new Set(existing.map((swap) => swap.id)), {
+      serverPubkey,
+      scanned,
+      reopen: existing.filter((swap) => isOpen(swap) && isOfferSwap(swap))
+    });
+  } catch (scanError) {
+    if (!signal?.aborted) {
+      try {
+        await restoreCoverage(wallet, arkServerUrl, existing);
+      } catch (coverageError2) {
+        throw new AggregateError(
+          [scanError, coverageError2],
+          "asset-swap scan and covenant coverage restore both failed"
+        );
+      }
+    }
+    throw scanError;
+  }
+  if (signal?.aborted) return aborted(existing);
+  const before = new Map(existing.map((swap) => [swap.id, swap]));
+  const changes = [];
+  const cancelledAfterCommit = async (scannedTxids = []) => ({
+    swaps: await getAssetSwapsOrThrow(repository),
+    changes,
+    scannedTxids,
+    aborted: true
+  });
+  for (const restored of scan.restored) {
+    if (signal?.aborted) return cancelledAfterCommit();
+    const previous = before.get(restored.id);
+    const current = previous !== void 0 || !prepareNew ? restored : await prepareNew(restored);
+    if (current.id !== restored.id) {
+      throw new Error("prepareNew must not change an asset swap id");
+    }
+    if (signal?.aborted) return cancelledAfterCommit();
+    await repository.saveSwap(current);
+    changes.push(previous ? { previous, current } : { current });
+    if (signal?.aborted) return cancelledAfterCommit();
+  }
+  if (signal?.aborted) return cancelledAfterCommit();
+  if (scan.scannedTxids.length > 0) {
+    await repository.markTxidsScanned(scan.scannedTxids);
+  }
+  const swaps = await getAssetSwapsOrThrow(repository);
+  if (signal?.aborted) return cancelledAfterCommit(scan.scannedTxids);
+  let coverageError;
+  try {
+    await restoreCoverage(wallet, arkServerUrl, swaps);
+  } catch (error) {
+    coverageError = error;
+  }
+  return {
+    swaps,
+    changes,
+    scannedTxids: scan.scannedTxids,
+    aborted: false,
+    ...coverageError === void 0 ? {} : { coverageError }
+  };
+}
+
+// src/registerRestore.ts
+var import_sdk6 = require("@arkade-os/sdk");
+var toRestoreTx = (tx) => ({
+  type: tx.type.toLowerCase(),
+  redeemTxid: tx.key.arkTxid,
+  boardingTxid: tx.key.boardingTxid,
+  roundTxid: tx.key.commitmentTxid,
+  createdAt: Math.floor(tx.createdAt / 1e3)
+});
+function registerAssetSwapRestore(wallet, options) {
+  return (0, import_sdk6.registerWalletRestoreHook)(wallet, {
+    id: "arkade-os:asset-swap",
+    restore: async (restoredWallet) => {
+      const dependencies = restoredWallet;
+      const indexer = options.indexer ?? dependencies.indexerProvider;
+      const serverPubkey = options.serverPubkey ?? dependencies.arkServerPublicKey;
+      if (!indexer) {
+        throw new Error("asset-swap restore requires an indexer");
+      }
+      if (!serverPubkey) {
+        throw new Error("asset-swap restore requires an Ark server public key");
+      }
+      const history = await restoredWallet.getTransactionHistory();
+      const result = await restoreAssetSwapRepository({
+        wallet: restoredWallet,
+        arkServerUrl: options.arkServerUrl,
+        indexer,
+        repository: options.repository,
+        txs: history.map(toRestoreTx),
+        serverPubkey,
+        prepareNew: options.prepareNew
+      });
+      await options.onResult?.(result);
+    }
+  });
+}
+
 // src/rfqCorridors.ts
-var import_base4 = require("@scure/base");
+var import_base5 = require("@scure/base");
 
 // src/rfqCorridor.ts
 var RfqCorridorRegistry = class {
@@ -1155,7 +1711,7 @@ var rfqClaimSecretOf = (record) => {
 };
 
 // src/onchainHtlc.ts
-var import_base3 = require("@scure/base");
+var import_base4 = require("@scure/base");
 var import_sha22 = require("@noble/hashes/sha2.js");
 var import_legacy = require("@noble/hashes/legacy.js");
 var btc = __toESM(require("@scure/btc-signer"), 1);
@@ -1166,8 +1722,8 @@ var LOCKTIME_THRESHOLD = 5e8;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
-var paymentHashOf = (preimage) => import_base3.hex.encode((0, import_sha22.sha256)(preimage));
-var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base3.hex.decode(paymentHash));
+var paymentHashOf = (preimage) => import_base4.hex.encode((0, import_sha22.sha256)(preimage));
+var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base4.hex.decode(paymentHash));
 var L1_NETWORKS = {
   bitcoin: btc.NETWORK,
   testnet: btc.TEST_NETWORK,
@@ -1219,7 +1775,7 @@ function onchainHtlcScript(params, network) {
   );
   const controlBlockFor = (leaf) => {
     for (const [block, script] of payment.tapLeafScript ?? []) {
-      if (script.length - 1 === leaf.length && import_base3.hex.encode(script.subarray(0, leaf.length)) === import_base3.hex.encode(leaf)) {
+      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);
       }
     }
@@ -1312,13 +1868,13 @@ var buildHtlcRefund = (input) => buildLeafSpend({
 function extractPreimage(txHex, paymentHash) {
   let raw;
   try {
-    raw = btc.RawTx.decode(import_base3.hex.decode(txHex));
+    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_base3.hex.encode((0, import_sha22.sha256)(item)) === paymentHash) return item;
+      if (item.length === 32 && import_base4.hex.encode((0, import_sha22.sha256)(item)) === paymentHash) return item;
     }
   }
   return null;
@@ -1363,7 +1919,7 @@ async function classifyOnchainHtlc(chain, input) {
     );
     if (!spend) return { phase: "unfunded" };
     const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
-    const txid = btc.Transaction.fromRaw(import_base3.hex.decode(spend.txHex), {
+    const txid = btc.Transaction.fromRaw(import_base4.hex.decode(spend.txHex), {
       allowUnknownInputs: true,
       allowUnknownOutputs: true
     }).id;
@@ -1414,13 +1970,13 @@ var LightningReceiveCorridor = {
 };
 function onchainSendProfile(result) {
   return {
-    claimKey: import_base4.hex.encode(result.htlcParams.claimKey),
-    refundKey: import_base4.hex.encode(result.htlcParams.refundKey),
+    claimKey: import_base5.hex.encode(result.htlcParams.claimKey),
+    refundKey: import_base5.hex.encode(result.htlcParams.refundKey),
     htlcLocktime: result.htlcParams.refundLocktime,
     network: result.l1Network,
     htlcAddress: result.htlc.address,
     minConfirmations: result.minConfirmations,
-    payoutPkScript: import_base4.hex.encode(result.payoutPkScript)
+    payoutPkScript: import_base5.hex.encode(result.payoutPkScript)
   };
 }
 var OnchainSendCorridor = {
@@ -1454,8 +2010,8 @@ var OnchainSendCorridor = {
         // unlocks both legs, but only one of the two hashes of it
         // is recoverable here.
         paymentHash,
-        claimKey: import_base4.hex.decode(profile.claimKey),
-        refundKey: import_base4.hex.decode(profile.refundKey),
+        claimKey: import_base5.hex.decode(profile.claimKey),
+        refundKey: import_base5.hex.decode(profile.refundKey),
         refundLocktime: profile.htlcLocktime
       },
       profile.network
@@ -1471,7 +2027,7 @@ var OnchainSendCorridor = {
       minConfirmations: profile.minConfirmations,
       // Optional here, required at the write: throwing on an older
       // record would strand the refund it is still owed.
-      ...profile.payoutPkScript ? { payoutPkScript: import_base4.hex.decode(profile.payoutPkScript) } : {},
+      ...profile.payoutPkScript ? { payoutPkScript: import_base5.hex.decode(profile.payoutPkScript) } : {},
       ...profile.funding ? { funding: profile.funding } : {},
       ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {}
     };
@@ -1489,8 +2045,8 @@ rfqCorridorHandlers.register(LightningReceiveCorridor);
 rfqCorridorHandlers.register(OnchainSendCorridor);
 
 // src/rfqRecord.ts
-var import_sdk5 = require("@arkade-os/sdk");
-var import_base5 = require("@scure/base");
+var import_sdk7 = require("@arkade-os/sdk");
+var import_base6 = require("@scure/base");
 
 // src/rfqSwapState.ts
 var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
@@ -1514,8 +2070,8 @@ function assertSameSwap(origin, swap) {
       `rfq swap record is a ${origin.kind} origin paired with a ${swap.kind} swap`
     );
   }
-  const funded = import_base5.hex.encode(import_sdk5.ArkAddress.decode(origin.lockupAddress).pkScript);
-  const watched = import_base5.hex.encode(swap.lockupPkScript);
+  const funded = import_base6.hex.encode(import_sdk7.ArkAddress.decode(origin.lockupAddress).pkScript);
+  const watched = import_base6.hex.encode(swap.lockupPkScript);
   if (funded !== watched) {
     throw new Error(
       `rfq swap record's lockup address holds ${funded}, but the swap watches ${watched} \u2014 these are not the same swap`
@@ -1559,11 +2115,11 @@ function rfqSwapOriginOf(record) {
   };
 }
 function lockupScript(params, lockupAddress) {
-  const script = import_sdk5.VHTLCV2ContractHandler.createScript(params);
-  const funded = import_sdk5.ArkAddress.decode(lockupAddress).pkScript;
-  if (import_base5.hex.encode(funded) !== import_base5.hex.encode(script.pkScript)) {
+  const script = import_sdk7.VHTLCV2ContractHandler.createScript(params);
+  const funded = import_sdk7.ArkAddress.decode(lockupAddress).pkScript;
+  if (import_base6.hex.encode(funded) !== import_base6.hex.encode(script.pkScript)) {
     throw new Error(
-      `rfq swap covenant params derive ${import_base5.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base5.hex.encode(funded)} \u2014 these params are not this swap's`
+      `rfq swap covenant params derive ${import_base6.hex.encode(script.pkScript)}, but the record's lockup address holds ${import_base6.hex.encode(funded)} \u2014 these params are not this swap's`
     );
   }
   return script;
@@ -1597,177 +2153,9 @@ function shouldRetainRfqSwap(record, now) {
   return now - record.updatedAt < RFQ_SWAP_RETENTION_SECONDS;
 }
 
-// src/restore.ts
-var import_base6 = require("@scure/base");
-var import_sdk6 = 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_sdk6.Transaction.fromPSBT(import_base6.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_base6.hex.encode(script.pkScript) !== import_base6.hex.encode(offer.swapPkScript)) return "indeterminate";
-    leaves = {
-      // both routes that hand the deposit back; `exit` is absent on an
-      // offer that carries no exit closure, and drops out here
-      returned: ["cancel", "exit"].map((name) => script.functionByName(name)?.leafScript).filter((leaf) => leaf !== void 0),
-      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_base6.hex.encode(input.txid) !== deposit.txid) continue;
-    for (const leaf of input.tapLeafScript ?? []) {
-      const spent = import_base6.hex.encode((0, import_sdk6.scriptFromTapLeafScript)(leaf));
-      if (leaves.returned.some((back) => spent === import_base6.hex.encode(back))) return "cancelled";
-      if (leaves.fulfill && spent === import_base6.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_sdk6.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
-      if (!packet) continue;
-      const payload = packet.serialize();
-      found.push({
-        fundingTx,
-        offer: decodeOffer(payload),
-        offerHex: import_base6.hex.encode(payload)
-      });
-    } catch {
-    }
-  }
-  if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
-  const scripts = [...new Set(found.map((f) => import_base6.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_base6.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_base6.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_base7 = require("@scure/base");
-var import_sdk7 = require("@arkade-os/sdk");
+var import_sdk8 = require("@arkade-os/sdk");
 var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
 function spendUpdate(swap, spend) {
   if (TERMINAL.includes(swap.status)) return void 0;
@@ -1787,8 +2175,8 @@ async function watchOfferSwaps({
   onUpdate
 }) {
   const manager = await wallet.getContractManager();
-  const serverPubkey = import_sdk7.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
-  const indexer = new import_sdk7.RestIndexerProvider(arkServerUrl);
+  const serverPubkey = import_sdk8.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
+  const indexer = new import_sdk8.RestIndexerProvider(arkServerUrl);
   let queue = Promise.resolve();
   const enqueue = (task) => {
     queue = queue.then(task).catch(() => {
@@ -1803,41 +2191,61 @@ async function watchOfferSwaps({
       return classifyDepositSpend(
         decodeOffer(import_base7.hex.decode(swap.offerHex)),
         serverPubkey,
-        txs.map((psbt) => import_sdk7.Transaction.fromPSBT(import_base7.base64.decode(psbt))),
+        txs.map((psbt) => import_sdk8.Transaction.fromPSBT(import_base7.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 resolveSpends = async (contractScript, vtxos, { at, known } = {}) => {
+    let swaps = known ?? await getAssetSwaps(repository);
+    for (const vtxo of 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
+      const swap = swaps.find(
+        (s) => s.fundingTxid === vtxo.txid && s.swapPkScript === contractScript
       );
       if (!swap) continue;
       const kind = await classify(swap, vtxo, spentTxid);
-      const changes = spendUpdate(swap, { txid: spentTxid, kind, at: event.timestamp });
+      const changes = spendUpdate(swap, { txid: spentTxid, kind, at });
       if (!changes) continue;
-      const { persisted, swaps } = await updateAssetSwapBestEffort(
+      const { persisted, swaps: written } = await updateAssetSwapBestEffort(
         repository,
         swap.id,
         changes
       );
       if (!persisted) continue;
+      swaps = written;
       onUpdate?.({ ...swap, ...changes });
       if (changes.status && RETIRABLE.includes(changes.status)) {
-        await retireOfferContract(manager, swaps, event.contractScript);
+        await retireOfferContract(manager, swaps, contractScript);
       }
     }
   };
+  const handleSpend = async (event) => {
+    if (event.contract.metadata?.kind !== OFFER_CONTRACT_KIND) return;
+    await resolveSpends(event.contractScript, event.vtxos, { at: event.timestamp });
+  };
+  const resolveOpenSwaps = async () => {
+    const swaps = await getAssetSwaps(repository);
+    const open = swaps.filter((s) => !TERMINAL.includes(s.status));
+    if (open.length === 0) return;
+    const script = [...new Set(open.map((s) => s.swapPkScript))];
+    for (const { contract, vtxos } of await manager.getContractsWithVtxos({ script })) {
+      if (contract.metadata?.kind !== OFFER_CONTRACT_KIND) continue;
+      await resolveSpends(
+        contract.script,
+        vtxos.filter((v) => v.isSpent),
+        { known: swaps }
+      );
+    }
+  };
   const unsubscribe = manager.onContractEvent((event) => {
-    if (!(0, import_sdk7.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
+    if (!(0, import_sdk8.isContractVtxoEvent)(event) || event.type !== "vtxo_spent") return;
     enqueue(() => handleSpend(event));
   });
+  enqueue(resolveOpenSwaps);
   return {
     stop: unsubscribe,
     idle: () => queue
@@ -1847,8 +2255,8 @@ async function watchOfferSwaps({
 // src/rfq.ts
 var import_base10 = require("@scure/base");
 var import_legacy2 = require("@noble/hashes/legacy.js");
-var import_sdk9 = require("@arkade-os/sdk");
 var import_sdk10 = require("@arkade-os/sdk");
+var import_sdk11 = require("@arkade-os/sdk");
 
 // src/claimPacket.ts
 var import_base8 = require("@scure/base");
@@ -1883,7 +2291,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
 
 // src/lockupContract.ts
 var import_base9 = require("@scure/base");
-var import_sdk8 = require("@arkade-os/sdk");
+var import_sdk9 = 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";
@@ -1919,7 +2327,7 @@ async function registerLockupContract(contracts, script, address) {
   try {
     await contracts.createContract({
       type: SWAP_LOCKUP_CONTRACT_TYPE,
-      params: import_sdk8.VHTLCV2ContractHandler.serializeParams(script.options),
+      params: import_sdk9.VHTLCV2ContractHandler.serializeParams(script.options),
       script: import_base9.hex.encode(script.pkScript),
       address,
       label: SWAP_LOCKUP_CONTRACT_LABEL,
@@ -1930,7 +2338,7 @@ async function registerLockupContract(contracts, script, address) {
   }
 }
 async function lockupContractParams(contracts, lockupAddress) {
-  const script = import_base9.hex.encode(import_sdk8.ArkAddress.decode(lockupAddress).pkScript);
+  const script = import_base9.hex.encode(import_sdk9.ArkAddress.decode(lockupAddress).pkScript);
   const [row] = await contracts.getContracts({ script });
   if (!row) throw new LockupContractMissing(lockupAddress, script);
   return row.params;
@@ -1955,14 +2363,78 @@ 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 RFQ_REFUSAL_ERROR_CODES = [
+  "amount_side_unsupported",
+  "exact_out_unsupported",
+  "invalid_amount",
+  "invalid_payout_address",
+  "invalid_refund_address",
+  "invoice_amount_mismatch",
+  "invoice_cltv_too_large",
+  "invoice_malformed",
+  "invoice_missing_amount",
+  "invoice_missing_network",
+  "invoice_missing_payment_hash",
+  "invoice_missing_timestamp",
+  "invoice_mixed_case",
+  "invoice_sub_satoshi_amount",
+  "invoice_too_long",
+  "invoice_wrong_network"
+];
+var isRfqRefusalErrorCode = (value) => typeof value === "string" && RFQ_REFUSAL_ERROR_CODES.includes(value);
+var REFUSAL_FIELDS = /* @__PURE__ */ new Set([
+  "amount",
+  "amount_side",
+  "profile.invoice",
+  "profile.payout_address",
+  "profile.refund_address"
+]);
+var REFUSAL_UNITS = /* @__PURE__ */ new Set(["blocks", "characters", "sats"]);
+var safeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+var safeRefusalDetail = (detail) => {
+  if (!isRfqRefusalErrorCode(detail.errorCode)) return {};
+  return {
+    errorCode: detail.errorCode,
+    field: typeof detail.field === "string" && REFUSAL_FIELDS.has(detail.field) ? detail.field : void 0,
+    actual: safeInteger(detail.actual),
+    expected: safeInteger(detail.expected),
+    limit: safeInteger(detail.limit),
+    unit: typeof detail.unit === "string" && REFUSAL_UNITS.has(detail.unit) ? detail.unit : void 0
+  };
+};
+var refusalMessage = (reason, detail) => {
+  if (!detail.errorCode) return `solver refused: ${reason}`;
+  const where = detail.field ? ` at ${detail.field}` : "";
+  const unit = detail.unit ? ` ${detail.unit}` : "";
+  if (detail.actual !== void 0 && detail.limit !== void 0) {
+    return `solver refused: ${reason} (${detail.errorCode}${where}: ${detail.actual}${unit}, limit ${detail.limit})`;
+  }
+  if (detail.actual !== void 0 && detail.expected !== void 0) {
+    return `solver refused: ${reason} (${detail.errorCode}${where}: ${detail.actual}${unit}, expected ${detail.expected})`;
+  }
+  return `solver refused: ${reason} (${detail.errorCode}${where})`;
+};
 var SwapRefusal = class extends Error {
   reason;
   rfqId;
-  constructor(reason, rfqId) {
-    super(`solver refused: ${reason}`);
+  errorCode;
+  field;
+  actual;
+  expected;
+  limit;
+  unit;
+  constructor(reason, rfqId, detail = {}) {
+    const safeDetail = safeRefusalDetail(detail);
+    super(refusalMessage(reason, safeDetail));
     this.name = "SwapRefusal";
     this.reason = reason;
     this.rfqId = rfqId;
+    this.errorCode = safeDetail.errorCode;
+    this.field = safeDetail.field;
+    this.actual = safeDetail.actual;
+    this.expected = safeDetail.expected;
+    this.limit = safeDetail.limit;
+    this.unit = safeDetail.unit;
   }
 };
 var AddressMismatch = class extends Error {
@@ -2081,8 +2553,8 @@ var assertFundable = (input) => {
       fail("max_fee_out_of_range", `maxFee.sats must be a non-negative integer, got ${sats}`);
     }
     const legs = input.quote.pair.split("->");
-    const assetOf = (leg) => leg.slice(leg.indexOf(":") + 1);
-    const sameAsset = legs.length === 2 && assetOf(legs[0]) === assetOf(legs[1]);
+    const assetOf2 = (leg) => leg.slice(leg.indexOf(":") + 1);
+    const sameAsset = legs.length === 2 && assetOf2(legs[0]) === assetOf2(legs[1]);
     if (!sameAsset && referenceRate === void 0) {
       fail(
         "fee_gate_unavailable",
@@ -2130,7 +2602,20 @@ var assertFundable = (input) => {
 };
 var expectQuote = (payload, rfqId, requestedPair) => {
   const p = payload;
-  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
+  if (p?.type === "rfq_refusal") {
+    throw new SwapRefusal(
+      p.reason ?? "unknown",
+      p.rfq_id ?? rfqId,
+      safeRefusalDetail({
+        errorCode: p.error_code,
+        field: p.field,
+        actual: p.actual,
+        expected: p.expected,
+        limit: p.limit,
+        unit: p.unit
+      })
+    );
+  }
   if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
     throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
   }
@@ -2283,7 +2768,7 @@ function lightningSendVtxoScript(params) {
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk9.VHTLC.ScriptV2({
+  return new import_sdk10.VHTLC.ScriptV2({
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
     server: params.serverPubkey,
@@ -2304,10 +2789,10 @@ function lightningSendVtxoScript(params) {
 }
 async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk10.provisionRefundKey)(wallet);
+  const secrets = await (0, import_sdk11.provisionRefundKey)(wallet);
   const senderPubkey = secrets.pubkey;
   const refundAddress = secrets.address;
-  const info = await new import_sdk9.RestArkProvider(arkServerUrl).getInfo();
+  const info = await new import_sdk10.RestArkProvider(arkServerUrl).getInfo();
   const quote = await transport.requestQuote(
     lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
   );
@@ -2328,16 +2813,16 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key");
-  const network = (0, import_sdk9.getNetwork)(info.network);
+  const serverPubkey = (0, import_sdk10.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key");
+  const network = (0, import_sdk10.getNetwork)(info.network);
   const treeParams = {
-    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
     serverPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    emulatorPubkey: (0, import_sdk9.toXOnly)(
-      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+    emulatorPubkey: (0, import_sdk10.toXOnly)(
+      import_base10.hex.decode((0, import_sdk10.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     senderPubkey,
@@ -2440,7 +2925,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2448,7 +2933,7 @@ function deriveOnchainSend(input) {
     emulatorPubkey: input.emulatorPubkey,
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk9.ArkAddress.decode(input.refundAddress).pkScript
+    refundPkScript: import_sdk10.ArkAddress.decode(input.refundAddress).pkScript
   };
   const { script, address } = matchQuotedLockup(
     quote,
@@ -2459,7 +2944,7 @@ function deriveOnchainSend(input) {
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
-    refundKey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(htlcPubkey), "solver L1 htlc key"),
+    refundKey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(htlcPubkey), "solver L1 htlc key"),
     refundLocktime: htlcLocktime
   };
   const htlc = onchainHtlcScript(htlcParams, input.l1Network);
@@ -2478,7 +2963,7 @@ function deriveOnchainSend(input) {
 }
 async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk10.provisionClaimSecret)(wallet, { preimage: params.preimage });
+  const secrets = await (0, import_sdk11.provisionClaimSecret)(wallet, { preimage: params.preimage });
   if (secrets.mustPersistPreimage) {
     console.warn(
       "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
@@ -2487,7 +2972,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk10.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -2502,14 +2987,14 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk9.getNetwork)(info.network);
+  const network = (0, import_sdk10.getNetwork)(info.network);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: (0, import_sdk9.toXOnly)(
-      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+    serverPubkey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: (0, import_sdk10.toXOnly)(
+      import_base10.hex.decode((0, import_sdk10.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2620,7 +3105,7 @@ function receiveVtxoScript(params) {
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk9.VHTLC.ScriptV2({
+  return new import_sdk10.VHTLC.ScriptV2({
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
     server: params.serverPubkey,
@@ -2649,7 +3134,7 @@ function deriveLightningReceive(input) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2657,7 +3142,7 @@ function deriveLightningReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk9.ArkAddress.decode(input.payoutAddress).pkScript
+    payoutPkScript: import_sdk10.ArkAddress.decode(input.payoutAddress).pkScript
   };
   const matched = matchQuotedLockup(
     quote,
@@ -2679,7 +3164,7 @@ function deriveLightningReceive(input) {
 }
 async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk10.provisionClaimSecret)(wallet);
+  const secrets = await (0, import_sdk11.provisionClaimSecret)(wallet);
   if (secrets.mustPersistPreimage) {
     console.warn(
       "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before paying"
@@ -2689,7 +3174,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
   const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk10.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = params.covclaimdPubkey ? await sealClaimPacket({
@@ -2708,15 +3193,15 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk9.getNetwork)(info.network);
+  const network = (0, import_sdk10.getNetwork)(info.network);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: (0, import_sdk9.toXOnly)(
-      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+    serverPubkey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: (0, import_sdk10.toXOnly)(
+      import_base10.hex.decode((0, import_sdk10.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2764,7 +3249,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2772,7 +3257,7 @@ function deriveOnchainReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk9.ArkAddress.decode(input.payoutAddress).pkScript
+    payoutPkScript: import_sdk10.ArkAddress.decode(input.payoutAddress).pkScript
   };
   const { script, address } = matchQuotedLockup(
     quote,
@@ -2783,7 +3268,7 @@ function deriveOnchainReceive(input) {
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -2802,7 +3287,7 @@ function deriveOnchainReceive(input) {
 }
 async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk10.provisionClaimSecret)(wallet);
+  const secrets = await (0, import_sdk11.provisionClaimSecret)(wallet);
   if (secrets.mustPersistPreimage) {
     console.warn(
       "[swap] this swap's preimage cannot be re-derived from the seed and MUST be persisted with the record before funding"
@@ -2812,7 +3297,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk10.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = params.covclaimdPubkey ? await sealClaimPacket({
@@ -2832,16 +3317,16 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk9.getNetwork)(info.network);
+  const network = (0, import_sdk10.getNetwork)(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: (0, import_sdk9.toXOnly)(
-      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+    serverPubkey: (0, import_sdk10.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: (0, import_sdk10.toXOnly)(
+      import_base10.hex.decode((0, import_sdk10.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2961,7 +3446,7 @@ var solverRendezvous = (markets, payoutCorridor, amountSats, fallbackEmulatorPub
 };
 
 // src/payment/solverOnchain.ts
-var import_sdk11 = require("@arkade-os/sdk");
+var import_sdk12 = require("@arkade-os/sdk");
 var SOLVER_ONCHAIN_RAIL = "solver-onchain";
 var solverOnchainRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "onchain", amountSats, fallbackEmulatorPubkey);
 function solverOnchainRail(deps) {
@@ -2972,24 +3457,24 @@ function solverOnchainRail(deps) {
   };
   return {
     id: SOLVER_ONCHAIN_RAIL,
-    match: (req) => (0, import_sdk11.btcTarget)(req.raw) !== void 0,
+    match: (req) => (0, import_sdk12.btcTarget)(req.raw) !== void 0,
     available: async (req) => {
-      if ((0, import_sdk11.assetsOf)(req).length > 0) return false;
-      const address = (0, import_sdk11.btcTarget)(req.raw);
+      if ((0, import_sdk12.assetsOf)(req).length > 0) return false;
+      const address = (0, import_sdk12.btcTarget)(req.raw);
       if (!address) return false;
       try {
         l1ScriptForAddress(address, deps.l1Network);
       } catch {
         return false;
       }
-      const amount = (0, import_sdk11.tryResolveSendAmount)(req.raw, req.amount);
+      const amount = (0, import_sdk12.tryResolveSendAmount)(req.raw, req.amount);
       if (amount === void 0) return false;
       return await rendezvousFor(amount) !== void 0;
     },
     quote: async (req, ctx) => {
-      const address = (0, import_sdk11.btcTarget)(req.raw);
-      (0, import_sdk11.assertNoAssets)(SOLVER_ONCHAIN_RAIL, req);
-      const amount = (0, import_sdk11.resolveSendAmount)(SOLVER_ONCHAIN_RAIL, req.raw, req.amount);
+      const address = (0, import_sdk12.btcTarget)(req.raw);
+      (0, import_sdk12.assertNoAssets)(SOLVER_ONCHAIN_RAIL, req);
+      const amount = (0, import_sdk12.resolveSendAmount)(SOLVER_ONCHAIN_RAIL, req.raw, req.amount);
       const payoutPkScript = l1ScriptForAddress(address, deps.l1Network);
       const rendezvous = await rendezvousFor(amount);
       if (!rendezvous) {
@@ -3017,6 +3502,7 @@ function solverOnchainRail(deps) {
         amount,
         fee: swap.fundAmount - amount,
         total: swap.fundAmount,
+        validUntil: swap.quote.valid_until,
         meta: {
           rfqId: swap.rfqId,
           validUntil: swap.quote.valid_until,
@@ -3027,7 +3513,7 @@ function solverOnchainRail(deps) {
           // not knowable now, so `amount` is the payout, not the net.
           claimFeeDeductedFromPayout: true
         },
-        send: async () => (0, import_sdk11.makeHandle)(SOLVER_ONCHAIN_RAIL, async (emit) => {
+        send: async () => (0, import_sdk12.makeHandle)(SOLVER_ONCHAIN_RAIL, async (emit) => {
           assertFundable({
             quote: swap.quote,
             now: Math.floor(Date.now() / 1e3),
@@ -3065,10 +3551,10 @@ function solverOnchainRail(deps) {
 }
 
 // src/payment/solverLightning.ts
-var import_sdk12 = require("@arkade-os/sdk");
+var import_sdk13 = require("@arkade-os/sdk");
 var SOLVER_LIGHTNING_RAIL = "solver-lightning";
 var factsOf = (raw, decode, now) => {
-  const invoice = (0, import_sdk12.invoiceTarget)(raw);
+  const invoice = (0, import_sdk13.invoiceTarget)(raw);
   if (!invoice) return void 0;
   let facts;
   try {
@@ -3085,16 +3571,16 @@ function solverLightningRail(deps) {
   const rendezvousFor = async (amountSats) => solverLightningRendezvous(await deps.discover(), amountSats, deps.fallbackEmulatorPubkey);
   return {
     id: SOLVER_LIGHTNING_RAIL,
-    match: (req) => (0, import_sdk12.invoiceTarget)(req.raw) !== void 0,
+    match: (req) => (0, import_sdk13.invoiceTarget)(req.raw) !== void 0,
     available: async (req) => {
-      if ((0, import_sdk12.assetsOf)(req).length > 0) return false;
+      if ((0, import_sdk13.assetsOf)(req).length > 0) return false;
       const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
       if (!facts) return false;
       if (req.amount !== void 0 && req.amount !== facts.amountSats) return false;
       return await rendezvousFor(facts.amountSats) !== void 0;
     },
     quote: async (req, ctx) => {
-      (0, import_sdk12.assertNoAssets)(SOLVER_LIGHTNING_RAIL, req);
+      (0, import_sdk13.assertNoAssets)(SOLVER_LIGHTNING_RAIL, req);
       const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
       if (!facts) {
         throw new Error(
@@ -3127,6 +3613,9 @@ function solverLightningRail(deps) {
         amount: facts.amountSats,
         fee: swap.fundAmount - facts.amountSats,
         total: swap.fundAmount,
+        // The invoice can lapse before the quote does; the earlier bound
+        // is the one a holder must observe.
+        validUntil: Math.min(swap.quote.valid_until, facts.expiresAt),
         meta: {
           rfqId: swap.rfqId,
           validUntil: swap.quote.valid_until,
@@ -3134,7 +3623,7 @@ function solverLightningRail(deps) {
           invoiceExpiresAt: facts.expiresAt,
           solverPubkey: rendezvous.solverPubkey
         },
-        send: async () => (0, import_sdk12.makeHandle)(SOLVER_LIGHTNING_RAIL, async (emit) => {
+        send: async () => (0, import_sdk13.makeHandle)(SOLVER_LIGHTNING_RAIL, async (emit) => {
           assertFundable({
             quote: swap.quote,
             invoiceExpiresAt: facts.expiresAt,
@@ -3168,16 +3657,17 @@ function solverLightningRail(deps) {
 }
 
 // src/payment/crossAsset.ts
-var import_sdk13 = require("@arkade-os/sdk");
+var import_sdk14 = require("@arkade-os/sdk");
 var CROSS_ASSET_RAIL = "cross-asset";
 var DEFAULT_CARRIER_SATS = 330;
 var parseAssetId = (assetId) => {
   try {
-    return import_sdk13.asset.AssetId.fromString(assetId);
+    return import_sdk14.asset.AssetId.fromString(assetId);
   } catch {
     return void 0;
   }
 };
+var marketLabel = (market) => `${market.base_asset.ticker || market.base_asset.id}/${market.quote_asset.ticker || market.quote_asset.id}`;
 function crossAssetRail(deps) {
   const planFor = async (asset3) => {
     const markets = await deps.discover();
@@ -3190,9 +3680,9 @@ function crossAssetRail(deps) {
   };
   return {
     id: CROSS_ASSET_RAIL,
-    match: (req) => (0, import_sdk13.arkTarget)(req.raw) !== void 0,
+    match: (req) => (0, import_sdk14.arkTarget)(req.raw) !== void 0,
     available: async (req) => {
-      const assets = (0, import_sdk13.assetsOf)(req);
+      const assets = (0, import_sdk14.assetsOf)(req);
       if (assets.length !== 1) return false;
       const [asset3] = assets;
       if (asset3.assetId === BTC_ASSET_ID) return false;
@@ -3202,8 +3692,8 @@ function crossAssetRail(deps) {
       return planned !== void 0 && planned.error === void 0;
     },
     quote: async (req, ctx) => {
-      const payTo = (0, import_sdk13.arkTarget)(req.raw);
-      const asset3 = (0, import_sdk13.resolveAssetAmount)(CROSS_ASSET_RAIL, req);
+      const payTo = (0, import_sdk14.arkTarget)(req.raw);
+      const asset3 = (0, import_sdk14.resolveAssetAmount)(CROSS_ASSET_RAIL, req);
       const wantAsset = parseAssetId(asset3.assetId);
       if (!wantAsset) {
         throw new Error(
@@ -3240,11 +3730,11 @@ function crossAssetRail(deps) {
           spent: { assetId: BTC_ASSET_ID, amount: plan.deposit.atomic }
         },
         meta: {
-          market: plan.market.pair,
+          market: marketLabel(plan.market),
           priceDisplay: plan.priceDisplay,
           give: plan.give
         },
-        send: async () => (0, import_sdk13.makeHandle)(CROSS_ASSET_RAIL, async (emit) => {
+        send: async () => (0, import_sdk14.makeHandle)(CROSS_ASSET_RAIL, async (emit) => {
           const offer = await createOffer(ctx.wallet, deps.arkServerUrl, {
             wantAmount: asset3.amount,
             wantAsset,
@@ -3293,7 +3783,7 @@ function crossAssetRail(deps) {
 var import_base13 = require("@scure/base");
 var import_legacy3 = require("@noble/hashes/legacy.js");
 var import_sha24 = require("@noble/hashes/sha2.js");
-var import_sdk14 = require("@arkade-os/sdk");
+var import_sdk15 = require("@arkade-os/sdk");
 var CovclaimdRevealError = class extends Error {
   name = "CovclaimdRevealError";
   status;
@@ -3397,7 +3887,7 @@ function revealFieldsFromScript(script) {
 }
 async function revealClaimPacket(client, input) {
   const fields = revealFieldsFromScript(input.script);
-  if (import_base13.hex.encode(import_sdk14.ArkAddress.decode(input.address).pkScript) !== import_base13.hex.encode(input.script.pkScript)) {
+  if (import_base13.hex.encode(import_sdk15.ArkAddress.decode(input.address).pkScript) !== import_base13.hex.encode(input.script.pkScript)) {
     throw new Error("address does not belong to this covenant");
   }
   if (import_base13.hex.encode((0, import_legacy3.ripemd160)((0, import_sha24.sha256)(input.preimage))) !== import_base13.hex.encode(input.script.options.preimageHash)) {
@@ -3415,12 +3905,12 @@ async function revealClaimPacket(client, input) {
 var import_base15 = require("@scure/base");
 var import_legacy4 = require("@noble/hashes/legacy.js");
 var import_sha26 = require("@noble/hashes/sha2.js");
-var import_sdk16 = require("@arkade-os/sdk");
+var import_sdk17 = require("@arkade-os/sdk");
 
 // src/refund.ts
 var import_base14 = require("@scure/base");
 var import_sha25 = require("@noble/hashes/sha2.js");
-var import_sdk15 = require("@arkade-os/sdk");
+var import_sdk16 = 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"];
@@ -3495,14 +3985,14 @@ async function findLockupVtxos(indexer, swapPkScript) {
 }
 var hashesTo = (candidate, paymentHash) => import_base14.hex.encode((0, import_sha25.sha256)(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
-  ...(0, import_sdk15.getArkPsbtFields)(tx, inputIndex, import_sdk15.ConditionWitness).flat(),
+  ...(0, import_sdk16.getArkPsbtFields)(tx, inputIndex, import_sdk16.ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
 ];
 async function readLockupFate(indexer, input) {
   const { vtxos } = await indexer.getVtxos({ scripts: [import_base14.hex.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
-  const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk15.hasTerminalSpend)(vtxo));
+  const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk16.hasTerminalSpend)(vtxo));
   if (exited.length > 0) {
     return {
       fate: "exited",
@@ -3512,7 +4002,7 @@ async function readLockupFate(indexer, input) {
   const spentBy = /* @__PURE__ */ new Map();
   let everySpendNamed = true;
   for (const vtxo of all) {
-    if (!(0, import_sdk15.hasTerminalSpend)(vtxo)) return { fate: "open" };
+    if (!(0, import_sdk16.hasTerminalSpend)(vtxo)) return { fate: "open" };
     if (vtxo.spentBy)
       spentBy.set(vtxo.spentBy, {
         checkpointTxid: vtxo.spentBy,
@@ -3526,7 +4016,7 @@ async function readLockupFate(indexer, input) {
   for (const raw of txs) {
     let tx;
     try {
-      tx = import_sdk15.Transaction.fromPSBT(import_base14.base64.decode(raw));
+      tx = import_sdk16.Transaction.fromPSBT(import_base14.base64.decode(raw));
     } catch {
       continue;
     }
@@ -3563,14 +4053,14 @@ async function pushRefundWithoutReceiver(ark, input) {
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk15.CSVMultisigTapscript.decode(import_base14.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk16.CSVMultisigTapscript.decode(import_base14.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_sdk15.buildOffchainTx)(
+  const { arkTx, checkpoints } = (0, import_sdk16.buildOffchainTx)(
     input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -3586,8 +4076,8 @@ async function pushRefundWithoutReceiver(ark, input) {
     import_base14.base64.encode(signedArkTx.toPSBT()),
     checkpoints.map((c) => import_base14.base64.encode(c.toPSBT()))
   );
-  (0, import_sdk15.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
-  const matched = (0, import_sdk15.matchServerCheckpoints)(
+  (0, import_sdk16.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
+  const matched = (0, import_sdk16.matchServerCheckpoints)(
     submitted.signedCheckpointTxs,
     checkpoints,
     "refundWithoutReceiver"
@@ -3695,14 +4185,14 @@ async function pushClaim(ark, input) {
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk16.CSVMultisigTapscript.decode(import_base15.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk17.CSVMultisigTapscript.decode(import_base15.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_sdk16.signAndSubmitOffchainTx)({
-    identity: (0, import_sdk16.claimWithPreimageIdentity)(input.receiver, input.preimage),
+  const arkTxid = await (0, import_sdk17.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk17.claimWithPreimageIdentity)(input.receiver, input.preimage),
     provider: ark,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
@@ -3749,7 +4239,7 @@ async function claimReceiveLockup(indexer, ark, input) {
 }
 
 // src/refundBlocked.ts
-var import_sdk17 = require("@arkade-os/sdk");
+var import_sdk18 = require("@arkade-os/sdk");
 var RefundNotLocallyPossibleError = class extends Error {
   constructor(reason, message, options) {
     super(message, options);
@@ -3766,16 +4256,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
     );
   }
   try {
-    return await (0, import_sdk17.contractSigner)(wallet, record.signingDescriptor);
+    return await (0, import_sdk18.contractSigner)(wallet, record.signingDescriptor);
   } catch (cause) {
-    if (cause instanceof import_sdk17.WalletCannotSignError) {
+    if (cause instanceof import_sdk18.WalletCannotSignError) {
       throw new RefundNotLocallyPossibleError(
         "unsignable-wallet",
         `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
         { cause }
       );
     }
-    if (cause instanceof import_sdk17.ForeignDescriptorError) {
+    if (cause instanceof import_sdk18.ForeignDescriptorError) {
       throw new RefundNotLocallyPossibleError(
         "foreign-descriptor",
         `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -3811,7 +4301,7 @@ function arkadeRefunder(deps) {
 
 // src/swapManager.ts
 var import_base16 = require("@scure/base");
-var import_sdk18 = require("@arkade-os/sdk");
+var import_sdk19 = require("@arkade-os/sdk");
 function nextOnchainAction(input) {
   switch (input.phase.phase) {
     case "unfunded":
@@ -4301,7 +4791,7 @@ var RfqSwapManager = class {
         });
         return;
       }
-      if (!(0, import_sdk18.isContractVtxoEvent)(event)) return;
+      if (!(0, import_sdk19.isContractVtxoEvent)(event)) return;
       const swap = this.byLockupScript.get(event.contractScript);
       if (!swap) return;
       void this.pollSwap(swap).catch(() => {
@@ -4848,7 +5338,7 @@ var errorMessage = (error) => error instanceof Error ? error.message : String(er
 var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 
 // src/activity.ts
-var import_sdk19 = require("@arkade-os/sdk");
+var import_sdk20 = require("@arkade-os/sdk");
 var import_base17 = require("@scure/base");
 var LABELS = {
   lightning_send: "Lightning send",
@@ -4924,7 +5414,7 @@ async function activityInputOf(record, indexer) {
 async function lockupTxids(indexer, record, wantFunding) {
   let script;
   try {
-    script = import_base17.hex.encode(import_sdk19.ArkAddress.decode(record.lockupAddress).pkScript);
+    script = import_base17.hex.encode(import_sdk20.ArkAddress.decode(record.lockupAddress).pkScript);
   } catch {
     return [];
   }
@@ -4944,6 +5434,7 @@ async function lockupTxids(indexer, record, wantFunding) {
 0 && (module.exports = {
   ARKADE_ASSET,
   ARKADE_BTC,
+  ASSET_CARRIER_SATS,
   AddressMismatch,
   BTC_ASSET_ID,
   CROSS_ASSET_RAIL,
@@ -4958,6 +5449,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   LockupContractMissing,
   LockupNeedsRecoveryError,
   LockupRegistrationFailed,
+  MARKET_CORRIDORS,
   MAX_MIN_CONFIRMATIONS,
   MIN_CLAIM_WINDOW_SECONDS,
   MIN_HEADROOM_SECONDS,
@@ -4972,6 +5464,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   PreimageNotRecoverableError,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
+  RFQ_REFUSAL_ERROR_CODES,
   RFQ_RESOLVED_STATES,
   RFQ_SWAP_RETENTION_SECONDS,
   RFQ_SWAP_TERMINAL_STATES,
@@ -5015,11 +5508,14 @@ async function lockupTxids(indexer, record, wantFunding) {
   discoverMarkets,
   encodeOffer,
   extractPreimage,
+  fillOffer,
   findLockupVtxos,
   findMarket,
   getAssetSwaps,
   getAssetSwapsOrThrow,
   httpTransport,
+  isRfqMarket,
+  isRfqRefusalErrorCode,
   isRfqSwapTerminal,
   isRfqTerminal,
   l1ScriptForAddress,
@@ -5028,6 +5524,9 @@ async function lockupTxids(indexer, record, wantFunding) {
   lightningSendVtxoScript,
   lockupContractParams,
   makeCachedFeedFetch,
+  marketAssetId,
+  marketCorridor,
+  marketPairLabel,
   newPreimage,
   newRfqId,
   nextOnchainAction,
@@ -5045,13 +5544,16 @@ async function lockupTxids(indexer, record, wantFunding) {
   rebuildRfqSwap,
   receiveVtxoScript,
   refundIfUnresolved,
+  registerAssetSwapRestore,
   registerLockupContract,
   relayTransport,
   requestLightningReceive,
   requestLightningSend,
   requestOnchainReceive,
   requestOnchainSend,
+  restoreAssetSwapRepository,
   restoreAssetSwaps,
+  restoreOfferCoverage,
   retireSettledOfferContracts,
   revealClaimPacket,
   revealFieldsFromScript,