@arkade-os/swap 0.0.7 → 0.0.8

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   LIGHTNING_RECEIVE_PAIR: () => LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR: () => LIGHTNING_SEND_PAIR,
   LockupAmountMismatchError: () => LockupAmountMismatchError,
+  LockupContractMissing: () => LockupContractMissing,
   LockupNeedsRecoveryError: () => LockupNeedsRecoveryError,
   LockupRegistrationFailed: () => LockupRegistrationFailed,
   MAX_MIN_CONFIRMATIONS: () => MAX_MIN_CONFIRMATIONS,
@@ -57,10 +58,12 @@ __export(index_exports, {
   QUOTE_OPTIONS: () => QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS: () => REFUND_MTP_LAG_SECONDS,
   RFQ_RESOLVED_STATES: () => RFQ_RESOLVED_STATES,
+  RFQ_SWAP_RETENTION_SECONDS: () => RFQ_SWAP_RETENTION_SECONDS,
   RFQ_SWAP_TERMINAL_STATES: () => RFQ_SWAP_TERMINAL_STATES,
   RFQ_TERMINAL_STATES: () => RFQ_TERMINAL_STATES,
   RefundNotLocallyPossibleError: () => RefundNotLocallyPossibleError,
   RfqSwapManager: () => RfqSwapManager,
+  RfqSwapOriginRequired: () => RfqSwapOriginRequired,
   SOLO_REFUND_HEADROOM_SECONDS: () => SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND: () => SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL: () => SWAP_LOCKUP_CONTRACT_LABEL,
@@ -68,6 +71,7 @@ __export(index_exports, {
   SwapRefusal: () => SwapRefusal,
   addAssetSwap: () => addAssetSwap,
   arkadeAssetLeg: () => arkadeAssetLeg,
+  arkadeRefunder: () => arkadeRefunder,
   arkadeSwapRequest: () => arkadeSwapRequest,
   assertFundable: () => assertFundable,
   assertReceivable: () => assertReceivable,
@@ -83,6 +87,7 @@ __export(index_exports, {
   classifyOnchainHtlc: () => classifyOnchainHtlc,
   classifySpend: () => classifySpend,
   createOffer: () => createOffer,
+  createRfqSwapRecord: () => createRfqSwapRecord,
   decodeOffer: () => decodeOffer,
   deriveLightningReceive: () => deriveLightningReceive,
   deriveOnchainReceive: () => deriveOnchainReceive,
@@ -100,6 +105,7 @@ __export(index_exports, {
   lightningReceiveRequest: () => lightningReceiveRequest,
   lightningSendRequest: () => lightningSendRequest,
   lightningSendVtxoScript: () => lightningSendVtxoScript,
+  lockupContractParams: () => lockupContractParams,
   makeCachedFeedFetch: () => makeCachedFeedFetch,
   newPreimage: () => newPreimage,
   newRfqId: () => newRfqId,
@@ -108,12 +114,14 @@ __export(index_exports, {
   offerVtxoScript: () => offerVtxoScript,
   onchainHtlcScript: () => onchainHtlcScript,
   onchainReceiveRequest: () => onchainReceiveRequest,
+  onchainSendProfile: () => onchainSendProfile,
   onchainSendRequest: () => onchainSendRequest,
   paymentHashOf: () => paymentHashOf,
   preimageForSwapRecord: () => preimageForSwapRecord,
   pushClaim: () => pushClaim,
   pushRefundWithoutReceiver: () => pushRefundWithoutReceiver,
   readLockupFate: () => readLockupFate,
+  rebuildRfqSwap: () => rebuildRfqSwap,
   receiveVtxoScript: () => receiveVtxoScript,
   refundIfUnresolved: () => refundIfUnresolved,
   registerLockupContract: () => registerLockupContract,
@@ -124,9 +132,15 @@ __export(index_exports, {
   requestOnchainSend: () => requestOnchainSend,
   restoreAssetSwaps: () => restoreAssetSwaps,
   retireSettledOfferContracts: () => retireSettledOfferContracts,
+  rfqClaimSecretOf: () => rfqClaimSecretOf,
   rfqPair: () => rfqPair,
+  rfqSecretsProfile: () => rfqSecretsProfile,
+  rfqSignerOf: () => rfqSignerOf,
+  rfqSwapActivityInputs: () => rfqSwapActivityInputs,
+  rfqSwapOriginOf: () => rfqSwapOriginOf,
   sealClaimPacket: () => sealClaimPacket,
   senderIdentityForSwapRecord: () => senderIdentityForSwapRecord,
+  shouldRetainRfqSwap: () => shouldRetainRfqSwap,
   spendTxidsOf: () => spendTxidsOf,
   spendUpdate: () => spendUpdate,
   swapActivityResolver: () => swapActivityResolver,
@@ -137,6 +151,7 @@ __export(index_exports, {
   unilateralRefundWithoutReceiverDelay: () => unilateralRefundWithoutReceiverDelay,
   updateAssetSwap: () => updateAssetSwap,
   updateAssetSwapBestEffort: () => updateAssetSwapBestEffort,
+  updateRfqSwapRecord: () => updateRfqSwapRecord,
   validatePlan: () => validatePlan,
   verifyLockupAddress: () => verifyLockupAddress,
   verifyReceiveInvoice: () => verifyReceiveInvoice,
@@ -762,8 +777,9 @@ var validatePlan = (plan, giveBalance, dust) => {
 // src/repository.ts
 var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
 var InMemoryAssetSwapRepository = class {
-  version = 2;
+  version = 4;
   swaps = /* @__PURE__ */ new Map();
+  rfqSwaps = /* @__PURE__ */ new Map();
   scanned = /* @__PURE__ */ new Set();
   markets = /* @__PURE__ */ new Map();
   async saveSwap(swap) {
@@ -772,6 +788,18 @@ var InMemoryAssetSwapRepository = class {
   async getAllSwaps() {
     return [...this.swaps.values()];
   }
+  async saveRfqSwap(record) {
+    this.rfqSwaps.set(record.rfqId, record);
+  }
+  async getRfqSwap(rfqId) {
+    return this.rfqSwaps.get(rfqId);
+  }
+  async getAllRfqSwaps() {
+    return [...this.rfqSwaps.values()];
+  }
+  async removeRfqSwap(rfqId) {
+    this.rfqSwaps.delete(rfqId);
+  }
   async getScannedTxids() {
     return new Set(this.scanned);
   }
@@ -786,6 +814,7 @@ var InMemoryAssetSwapRepository = class {
   }
   async clear() {
     this.swaps.clear();
+    this.rfqSwaps.clear();
     this.scanned.clear();
     this.markets.clear();
   }
@@ -796,58 +825,44 @@ var InMemoryAssetSwapRepository = class {
 // src/indexedDbRepository.ts
 var import_sdk4 = require("@arkade-os/sdk");
 var DEFAULT_DB_NAME = "arkade-intents";
-var DB_VERSION = 1;
+var DB_VERSION = 2;
 var STORE_SWAPS = "swaps";
+var STORE_RFQ_SWAPS = "rfqSwaps";
 var STORE_SCANNED = "scannedTxids";
 var STORE_MARKETS = "markets";
 var STORES = [
   [STORE_SWAPS, { keyPath: "id" }],
+  // v2. Separate from `swaps` rather than sharing it: the two record types
+  // have different keys and no consumer wants them interleaved.
+  [STORE_RFQ_SWAPS, { keyPath: "rfqId" }],
   [STORE_SCANNED],
   [STORE_MARKETS]
 ];
-function initDatabase(db) {
+function initDatabase(db, oldVersion, transaction) {
+  void oldVersion;
+  void transaction;
   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 {
+  version = 4;
+  connection;
   constructor(dbName = DEFAULT_DB_NAME) {
-    this.dbName = dbName;
-  }
-  dbName;
-  version = 2;
-  // 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;
+    this.connection = (0, import_sdk4.createManagedConnection)(dbName, DB_VERSION, initDatabase);
+  }
   ensureDb() {
-    return this.dbPromise ??= (0, import_sdk4.openDatabase)(this.dbName, DB_VERSION, initDatabase).catch(
-      (err) => {
-        this.dbPromise = null;
-        throw err;
-      }
-    );
+    return this.connection.get();
   }
   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. */
+   * transaction, which `awaitTransaction` reports. */
   async write(name, apply) {
     const tx = (await this.ensureDb()).transaction([name], "readwrite");
-    const done = txDone(tx);
+    const done = (0, import_sdk4.awaitTransaction)(tx);
     apply(tx.objectStore(name));
     await done;
   }
@@ -857,10 +872,26 @@ var IndexedDbAssetSwapRepository = class {
     });
   }
   async getAllSwaps() {
-    return request((await this.readStore(STORE_SWAPS)).getAll());
+    return (0, import_sdk4.promisifyRequest)((await this.readStore(STORE_SWAPS)).getAll());
+  }
+  async saveRfqSwap(record) {
+    await this.write(STORE_RFQ_SWAPS, (store) => {
+      store.put(record);
+    });
+  }
+  async getRfqSwap(rfqId) {
+    return (0, import_sdk4.promisifyRequest)((await this.readStore(STORE_RFQ_SWAPS)).get(rfqId));
+  }
+  async getAllRfqSwaps() {
+    return (0, import_sdk4.promisifyRequest)((await this.readStore(STORE_RFQ_SWAPS)).getAll());
+  }
+  async removeRfqSwap(rfqId) {
+    await this.write(STORE_RFQ_SWAPS, (store) => {
+      store.delete(rfqId);
+    });
   }
   async getScannedTxids() {
-    const keys = await request((await this.readStore(STORE_SCANNED)).getAllKeys());
+    const keys = await (0, import_sdk4.promisifyRequest)((await this.readStore(STORE_SCANNED)).getAllKeys());
     return new Set(keys);
   }
   async markTxidsScanned(txids) {
@@ -870,7 +901,7 @@ var IndexedDbAssetSwapRepository = class {
   }
   async getCachedMarkets(network, registry) {
     const store = await this.readStore(STORE_MARKETS);
-    return request(store.get(marketsCacheKey(network, registry)));
+    return (0, import_sdk4.promisifyRequest)(store.get(marketsCacheKey(network, registry)));
   }
   async saveCachedMarkets(network, registry, entry) {
     await this.write(STORE_MARKETS, (store) => {
@@ -883,269 +914,136 @@ var IndexedDbAssetSwapRepository = class {
   async clear() {
     const stores = STORES.map(([name]) => name);
     const tx = (await this.ensureDb()).transaction(stores, "readwrite");
-    const done = txDone(tx);
+    const done = (0, import_sdk4.awaitTransaction)(tx);
     for (const name of stores) tx.objectStore(name).clear();
     await done;
   }
   async [Symbol.asyncDispose]() {
-    if (!this.dbPromise) return;
-    await (0, import_sdk4.closeDatabase)(this.dbName);
-    this.dbPromise = null;
+    await this.connection[Symbol.asyncDispose]();
   }
 };
 
-// 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 {
-      }
+// src/rfqCorridors.ts
+var import_base4 = require("@scure/base");
+
+// src/rfqCorridor.ts
+var RfqCorridorRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  register(handler) {
+    if (this.handlers.has(handler.kind)) {
+      throw new Error(
+        `RFQ corridor handler for kind '${handler.kind}' is already registered`
+      );
     }
+    this.handlers.set(handler.kind, handler);
   }
-  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 = {
-      cancel: script.functionByName("cancel")?.leafScript,
-      fulfill: script.functionByName("fulfill")?.leafScript
-    };
-  } catch {
-    return "indeterminate";
-  }
-  for (let i = 0; i < spendTx.inputsLength; i++) {
-    const input = spendTx.getInput(i);
-    if (!input.txid || input.index !== deposit.vout) continue;
-    if (import_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.cancel && spent === import_base3.hex.encode(leaves.cancel)) return "cancelled";
-      if (leaves.fulfill && spent === import_base3.hex.encode(leaves.fulfill)) return "fulfilled";
-    }
+  /** Takes a bare `string`, deliberately, where {@link RfqCorridorHandler.kind}
+   * is the manager's union: a lookup key comes off a record a backend handed
+   * back, and that it typechecks as a `kind` is a claim about the type, not
+   * about what was stored. Narrowing this would read as a check already made. */
+  get(kind) {
+    return this.handlers.get(kind);
   }
-  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_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 {
+  /**
+   * The handler for a kind, or a loud failure.
+   *
+   * A record whose corridor is not registered cannot be restored, and
+   * guessing would monitor a swap with no idea how to drive it. Names the
+   * registered kinds so a missing `register()` call is obvious.
+   */
+  getOrThrow(kind) {
+    const handler = this.get(kind);
+    if (!handler) {
+      throw new Error(
+        `no RFQ corridor handler registered for kind '${kind}'; registered: ${this.registeredKinds().join(", ") || "none"}`
+      );
     }
+    return handler;
   }
-  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);
-    }
+  has(kind) {
+    return this.handlers.has(kind);
   }
-  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);
+  registeredKinds() {
+    return [...this.handlers.keys()];
   }
-  const spendTxByTxid = await fetchParsedTxs(indexer, [...spendTxids]);
-  const restored = [];
-  const unresolved = /* @__PURE__ */ new Set();
-  for (const { fundingTx, offer, offerHex } 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;
-    }
-    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 } : {}
-    });
+  /** Test seam, mirroring the contract registry's. */
+  unregister(kind) {
+    return this.handlers.delete(kind);
   }
-  return { restored, scannedTxids: fetchedTxids.filter((id) => !unresolved.has(id)) };
-}
+};
+var rfqCorridorHandlers = new RfqCorridorRegistry();
 
-// src/watch.ts
-var import_base4 = require("@scure/base");
-var import_sdk6 = require("@arkade-os/sdk");
-var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
-function spendUpdate(swap, spend) {
-  if (TERMINAL.includes(swap.status)) return void 0;
-  if (spend.kind === "indeterminate") return void 0;
-  const status = spend.kind === "cancelled" ? "cancelled" : "fulfilled";
+// src/rfqProfileParts.ts
+var rfqSecretsProfile = (secrets, paymentHash) => {
+  const { signingDescriptor, ...preimage } = swapSecretsToRecord(secrets);
   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 } : {}
+    signer: { signingDescriptor },
+    ...paymentHash ? { hashlock: { paymentHash, ...preimage } } : {}
   };
-}
-async function watchOfferSwaps({
-  wallet,
-  arkServerUrl,
-  repository,
-  onUpdate
-}) {
-  const manager = await wallet.getContractManager();
-  const serverPubkey = import_sdk6.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
-  const indexer = new import_sdk6.RestIndexerProvider(arkServerUrl);
-  let queue = Promise.resolve();
-  const enqueue = (task) => {
-    queue = queue.then(task).catch(() => {
-    });
-  };
-  const classify = async (swap, vtxo, spentTxid) => {
-    if (swap.spentTxid === spentTxid && swap.status === "cancelling") return "cancelled";
-    try {
-      const candidates = spendTxidsOf(vtxo);
-      if (candidates.length === 0) return "indeterminate";
-      const { txs } = await indexer.getVirtualTxs(candidates);
-      return classifyDepositSpend(
-        decodeOffer(import_base4.hex.decode(swap.offerHex)),
-        serverPubkey,
-        txs.map((psbt) => import_sdk6.Transaction.fromPSBT(import_base4.base64.decode(psbt))),
-        { txid: vtxo.txid, vout: vtxo.vout }
-      );
-    } catch {
-      return "indeterminate";
-    }
-  };
-  const handleSpend = async (event) => {
-    if (event.contract.metadata?.kind !== OFFER_CONTRACT_KIND) return;
-    for (const vtxo of event.vtxos) {
-      const spentTxid = vtxo.arkTxId || vtxo.spentBy;
-      if (!spentTxid) continue;
-      const swap = (await getAssetSwaps(repository)).find(
-        (s) => s.fundingTxid === vtxo.txid && s.swapPkScript === event.contractScript
-      );
-      if (!swap) continue;
-      const kind = await classify(swap, vtxo, spentTxid);
-      const changes = spendUpdate(swap, { txid: spentTxid, kind, at: event.timestamp });
-      if (!changes) continue;
-      const { persisted, swaps } = await updateAssetSwapBestEffort(
-        repository,
-        swap.id,
-        changes
-      );
-      if (!persisted) continue;
-      onUpdate?.({ ...swap, ...changes });
-      if (changes.status && RETIRABLE.includes(changes.status)) {
-        await retireOfferContract(manager, swaps, event.contractScript);
-      }
-    }
-  };
-  const unsubscribe = manager.onContractEvent((event) => {
-    if (event.type !== "vtxo_spent") return;
-    enqueue(() => handleSpend(event));
-  });
-  return {
-    stop: unsubscribe,
-    idle: () => queue
+};
+var parseHex32 = (value, field) => {
+  if (typeof value !== "string" || !/^[0-9a-fA-F]{64}$/.test(value)) {
+    throw new Error(`${field} must be 32 bytes of hex, got ${JSON.stringify(value)}`);
+  }
+  return value.toLowerCase();
+};
+var parseSigner = (value) => {
+  const signingDescriptor = value?.signingDescriptor;
+  if (typeof signingDescriptor !== "string" || signingDescriptor.length === 0) {
+    throw new Error(
+      `rfq profile.signer carries no signingDescriptor (got ${JSON.stringify(signingDescriptor)})`
+    );
+  }
+  return { signingDescriptor };
+};
+var parseHashlock = (value) => {
+  const raw = value ?? {};
+  const hashlock = {
+    paymentHash: parseHex32(raw.paymentHash, "rfq profile.hashlock.paymentHash")
   };
-}
-
-// src/rfq.ts
-var import_base8 = require("@scure/base");
-var import_legacy2 = require("@noble/hashes/legacy.js");
-var import_sdk8 = require("@arkade-os/sdk");
+  if (raw.preimageHex !== void 0) {
+    hashlock.preimageHex = parseHex32(raw.preimageHex, "rfq profile.hashlock.preimageHex");
+  }
+  if (raw.preimageSaltHex !== void 0) {
+    hashlock.preimageSaltHex = parseHex32(
+      raw.preimageSaltHex,
+      "rfq profile.hashlock.preimageSaltHex"
+    );
+  }
+  return hashlock;
+};
+var hydrateHashlock = (profile) => {
+  try {
+    return { paymentHash: parseHashlock(profile.hashlock).paymentHash };
+  } catch (cause) {
+    throw new Error(
+      `rfq record carries no usable hashlock; it cannot verify a preimage: ${String(cause)}`,
+      { cause }
+    );
+  }
+};
+var rfqSignerOf = (record) => {
+  const signer = record.profile.signer;
+  if (signer === void 0) return void 0;
+  return parseSigner(signer);
+};
+var rfqClaimSecretOf = (record) => {
+  const handler = rfqCorridorHandlers.getOrThrow(record.kind);
+  if (!handler.claimSecret) return void 0;
+  try {
+    const claim = handler.claimSecret(record.profile);
+    return { ...parseSigner(claim), ...parseHashlock(claim) };
+  } catch (cause) {
+    throw new PreimageNotRecoverableError(
+      "malformed-record",
+      `this ${record.kind} record's claim secret is unreadable: ${String(cause)}`,
+      { cause }
+    );
+  }
+};
 
 // src/onchainHtlc.ts
-var import_base5 = require("@scure/base");
+var import_base3 = 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);
@@ -1155,8 +1053,8 @@ var MAX_MIN_CONFIRMATIONS = 6;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
-var paymentHashOf = (preimage) => import_base5.hex.encode((0, import_sha22.sha256)(preimage));
-var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base5.hex.decode(paymentHash));
+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 L1_NETWORKS = {
   bitcoin: btc.NETWORK,
   testnet: btc.TEST_NETWORK,
@@ -1171,6 +1069,11 @@ function onchainHtlcScript(params, network) {
       `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
     );
   }
+  if (!Object.hasOwn(L1_NETWORKS, network)) {
+    throw new Error(
+      `unknown L1 network '${String(network)}' \u2014 expected one of ${Object.keys(L1_NETWORKS).join(", ")}`
+    );
+  }
   const h160 = h160FromPaymentHash(params.paymentHash);
   const claim = btc.Script.encode([
     "SIZE",
@@ -1197,7 +1100,7 @@ function onchainHtlcScript(params, network) {
   );
   const controlBlockFor = (leaf) => {
     for (const [block, script] of payment.tapLeafScript ?? []) {
-      if (script.length - 1 === leaf.length && import_base5.hex.encode(script.subarray(0, leaf.length)) === import_base5.hex.encode(leaf)) {
+      if (script.length - 1 === leaf.length && import_base3.hex.encode(script.subarray(0, leaf.length)) === import_base3.hex.encode(leaf)) {
         return btc.TaprootControlBlock.encode(block);
       }
     }
@@ -1290,13 +1193,13 @@ var buildHtlcRefund = (input) => buildLeafSpend({
 function extractPreimage(txHex, paymentHash) {
   let raw;
   try {
-    raw = btc.RawTx.decode(import_base5.hex.decode(txHex));
+    raw = btc.RawTx.decode(import_base3.hex.decode(txHex));
   } catch {
     return null;
   }
   for (const stack of raw.witnesses ?? []) {
     for (const item of stack) {
-      if (item.length === 32 && import_base5.hex.encode((0, import_sha22.sha256)(item)) === paymentHash) return item;
+      if (item.length === 32 && import_base3.hex.encode((0, import_sha22.sha256)(item)) === paymentHash) return item;
     }
   }
   return null;
@@ -1316,45 +1219,510 @@ async function awaitOnchainFill(chain, htlc, minConfirmations, options = {}) {
     await sleep(pollMs);
   }
 }
-async function claimOnchainFill(chain, input) {
-  const now = input.now ?? Math.floor(Date.now() / 1e3);
-  if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
-    const error = new Error(
-      "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
-    );
-    error.reason = "claim_window_closed";
-    throw error;
-  }
-  const spend = await buildHtlcClaim(input);
-  const txid = await chain.broadcast(spend.txHex);
-  return { txid, payoutAmount: spend.payoutAmount };
+async function claimOnchainFill(chain, input) {
+  const now = input.now ?? Math.floor(Date.now() / 1e3);
+  if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
+    const error = new Error(
+      "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
+    );
+    error.reason = "claim_window_closed";
+    throw error;
+  }
+  const spend = await buildHtlcClaim(input);
+  const txid = await chain.broadcast(spend.txHex);
+  return { txid, payoutAmount: spend.payoutAmount };
+}
+async function classifyOnchainHtlc(chain, input) {
+  const utxos = await chain.getScriptUtxos(input.htlc.pkScript);
+  const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
+  if (!best) {
+    if (!input.funding) return { phase: "unfunded" };
+    const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
+    if (!spend) return { phase: "unfunded" };
+    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
+    const txid = btc.Transaction.fromRaw(import_base3.hex.decode(spend.txHex), {
+      allowUnknownInputs: true,
+      allowUnknownOutputs: true
+    }).id;
+    return preimage ? { phase: "claimed", txid, preimage } : { phase: "swept", txid };
+  }
+  if (best.confirmations < input.minConfirmations)
+    return { phase: "awaiting_confirmations", utxo: best };
+  const mtp = await chain.getMtp();
+  if (mtp >= input.htlc.refundLocktime) return { phase: "refundable", utxo: best };
+  return { phase: "claimable", utxo: best };
+}
+
+// src/rfqCorridors.ts
+var LightningSendCorridor = {
+  kind: "lightning_send",
+  project: () => ({}),
+  hydrate: (profile) => hydrateHashlock(profile)
+  // No `claimSecret`, deliberately: `provisionRefundKey` mints no preimage at
+  // all, and deriving one off the refund descriptor would fail the payment
+  // hash check — a `hash-mismatch` on a swap that was never broken.
+};
+var LightningReceiveCorridor = {
+  kind: "lightning_receive",
+  // What the manager holds: the amount gate, and its own claim once it lands.
+  // `payoutAddress` comes from the request result and never changes, so the
+  // caller writes it once and this leaves it alone.
+  project: (swap) => {
+    const receive = swap;
+    return {
+      expectedAmount: receive.expectedAmount,
+      ...receive.claimArkTxid ? { claimArkTxid: receive.claimArkTxid } : {}
+    };
+  },
+  hydrate(profile) {
+    if (typeof profile.expectedAmount !== "number" || !Number.isFinite(profile.expectedAmount)) {
+      throw new Error("lightning_receive record carries no expectedAmount; it cannot claim");
+    }
+    return {
+      ...hydrateHashlock(profile),
+      expectedAmount: profile.expectedAmount,
+      ...profile.claimArkTxid ? { claimArkTxid: profile.claimArkTxid } : {}
+    };
+  },
+  // We are the claimant here, so the preimage material on the hashlock is
+  // ours to use.
+  claimSecret: (profile) => ({ ...profile.signer, ...profile.hashlock }),
+  activityTxids: (profile) => profile.claimArkTxid ? [profile.claimArkTxid] : []
+};
+function onchainSendProfile(result) {
+  return {
+    claimKey: import_base4.hex.encode(result.htlcParams.claimKey),
+    refundKey: import_base4.hex.encode(result.htlcParams.refundKey),
+    htlcLocktime: result.htlcParams.refundLocktime,
+    network: result.l1Network,
+    htlcAddress: result.htlc.address,
+    minConfirmations: result.minConfirmations
+  };
+}
+var OnchainSendCorridor = {
+  kind: "onchain_send",
+  // The L1 keys and the network are only in the request result — nothing on
+  // `OnchainSendSwap` carries them — so the caller writes them once. What the
+  // manager learns as it drives the swap is the fill and our own claim.
+  project: (swap) => {
+    const send = swap;
+    return {
+      ...send.funding ? { funding: send.funding } : {},
+      ...send.claimTxid ? { claimTxid: send.claimTxid } : {}
+    };
+  },
+  hydrate(profile) {
+    const { paymentHash } = hydrateHashlock(profile);
+    if (!profile.claimKey || !profile.refundKey) {
+      throw new Error(
+        "onchain_send record carries no L1 keys; its HTLC cannot be rebuilt and its refund window would pass unwatched"
+      );
+    }
+    if (!Number.isInteger(profile.minConfirmations) || profile.minConfirmations < 1) {
+      throw new Error(
+        `onchain_send record carries no usable minConfirmations (${String(profile.minConfirmations)}); the confirmation gate cannot be checked \u2014 refusing to restore a swap that would claim an unconfirmed fill`
+      );
+    }
+    const htlc = onchainHtlcScript(
+      {
+        // From the profile, not the covenant: the lockup commits to
+        // `hash160(P)`, and the HTLC needs `sha256(P)`. One P
+        // 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),
+        refundLocktime: profile.htlcLocktime
+      },
+      profile.network
+    );
+    if (htlc.address !== profile.htlcAddress) {
+      throw new Error(
+        `onchain_send record's L1 inputs derive ${htlc.address}, but the fill was expected at ${String(profile.htlcAddress)} \u2014 these are not this swap's`
+      );
+    }
+    return {
+      paymentHash,
+      htlc,
+      minConfirmations: profile.minConfirmations,
+      ...profile.funding ? { funding: profile.funding } : {},
+      ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {}
+    };
+  },
+  // The trader claims the L1 HTLC with P, so this leg's preimage material is
+  // ours.
+  claimSecret: (profile) => ({ ...profile.signer, ...profile.hashlock }),
+  // Our own L1 claim only. `funding` is the SOLVER's fill into the HTLC —
+  // not a transaction of ours, so grouping it would claim a row this wallet
+  // never made.
+  activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
+};
+rfqCorridorHandlers.register(LightningSendCorridor);
+rfqCorridorHandlers.register(LightningReceiveCorridor);
+rfqCorridorHandlers.register(OnchainSendCorridor);
+
+// src/rfqRecord.ts
+var import_sdk5 = require("@arkade-os/sdk");
+var import_base5 = require("@scure/base");
+
+// src/rfqSwapState.ts
+var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
+var isRfqSwapTerminal = (state) => RFQ_SWAP_TERMINAL_STATES.includes(state);
+
+// src/rfqRecord.ts
+var RFQ_SWAP_RETENTION_SECONDS = 30 * 24 * 60 * 60;
+var managerState = (swap) => ({
+  rfqId: swap.rfqId,
+  state: swap.state,
+  createdAt: swap.createdAt,
+  updatedAt: swap.updatedAt,
+  ...swap.refundArkTxid ? { refundArkTxid: swap.refundArkTxid } : {},
+  ...swap.lockupSpendArkTxids?.length ? { lockupSpendArkTxids: [...swap.lockupSpendArkTxids] } : {},
+  ...swap.failure ? { failure: swap.failure } : {},
+  ...swap.blockedReason ? { blockedReason: swap.blockedReason } : {}
+});
+function assertSameSwap(origin, swap) {
+  if (origin.kind !== swap.kind) {
+    throw new Error(
+      `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);
+  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`
+    );
+  }
+}
+function createRfqSwapRecord(origin, swap) {
+  assertSameSwap(origin, swap);
+  const handler = rfqCorridorHandlers.getOrThrow(origin.kind);
+  return {
+    ...origin,
+    ...managerState(swap),
+    // The caller wrote what only the request result knows; the handler adds
+    // what the live swap already carries.
+    profile: { ...origin.profile, ...handler.project(swap) }
+  };
+}
+function updateRfqSwapRecord(record, swap) {
+  assertSameSwap(record, swap);
+  const {
+    refundArkTxid: _refundArkTxid,
+    lockupSpendArkTxids: _lockupSpendArkTxids,
+    failure: _failure,
+    blockedReason: _blockedReason,
+    ...origin
+  } = record;
+  const handler = rfqCorridorHandlers.getOrThrow(record.kind);
+  return {
+    ...origin,
+    ...managerState(swap),
+    profile: { ...record.profile, ...handler.project(swap) }
+  };
+}
+function rfqSwapOriginOf(record) {
+  return {
+    kind: record.kind,
+    lockupAddress: record.lockupAddress,
+    profile: { ...record.profile },
+    ...record.amount !== void 0 ? { amount: record.amount } : {},
+    ...record.fundingArkTxid ? { fundingArkTxid: record.fundingArkTxid } : {}
+  };
+}
+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)) {
+    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`
+    );
+  }
+  return script;
+}
+function rebuildRfqSwap(record, params) {
+  const script = lockupScript(params, record.lockupAddress);
+  const common = {
+    rfqId: record.rfqId,
+    state: record.state,
+    lockupPkScript: script.pkScript,
+    lockup: { script, address: record.lockupAddress },
+    // From the covenant, which binds it: the record's own copy would be a
+    // second source for the deadline the refund is gated on.
+    refundLocktime: Number(script.options.refundLocktime),
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    ...record.refundArkTxid ? { refundArkTxid: record.refundArkTxid } : {},
+    ...record.lockupSpendArkTxids?.length ? { lockupSpendArkTxids: [...record.lockupSpendArkTxids] } : {},
+    ...record.failure ? { failure: record.failure } : {},
+    ...record.blockedReason ? { blockedReason: record.blockedReason } : {}
+  };
+  const handler = rfqCorridorHandlers.getOrThrow(record.kind);
+  return {
+    ...common,
+    kind: record.kind,
+    ...handler.hydrate(record.profile, { lockup: script })
+  };
+}
+function shouldRetainRfqSwap(record, now) {
+  if (!isRfqSwapTerminal(record.state)) return true;
+  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 = {
+      cancel: script.functionByName("cancel")?.leafScript,
+      fulfill: script.functionByName("fulfill")?.leafScript
+    };
+  } catch {
+    return "indeterminate";
+  }
+  for (let i = 0; i < spendTx.inputsLength; i++) {
+    const input = spendTx.getInput(i);
+    if (!input.txid || input.index !== deposit.vout) continue;
+    if (import_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.cancel && spent === import_base6.hex.encode(leaves.cancel)) 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 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 classifyOnchainHtlc(chain, input) {
-  const utxos = await chain.getScriptUtxos(input.htlc.pkScript);
-  const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
-  if (!best) {
-    if (!input.funding) return { phase: "unfunded" };
-    const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
-    if (!spend) return { phase: "unfunded" };
-    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
-    const txid = btc.Transaction.fromRaw(import_base5.hex.decode(spend.txHex), {
-      allowUnknownInputs: true,
-      allowUnknownOutputs: true
-    }).id;
-    return preimage ? { phase: "claimed", txid, preimage } : { phase: "swept", txid };
-  }
-  if (best.confirmations < input.minConfirmations)
-    return { phase: "awaiting_confirmations", utxo: best };
-  const mtp = await chain.getMtp();
-  if (mtp >= input.htlc.refundLocktime) return { phase: "refundable", utxo: best };
-  return { phase: "claimable", utxo: best };
+async function watchOfferSwaps({
+  wallet,
+  arkServerUrl,
+  repository,
+  onUpdate
+}) {
+  const manager = await wallet.getContractManager();
+  const serverPubkey = import_sdk7.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
+  const indexer = new import_sdk7.RestIndexerProvider(arkServerUrl);
+  let queue = Promise.resolve();
+  const enqueue = (task) => {
+    queue = queue.then(task).catch(() => {
+    });
+  };
+  const classify = async (swap, vtxo, spentTxid) => {
+    if (swap.spentTxid === spentTxid && swap.status === "cancelling") return "cancelled";
+    try {
+      const candidates = spendTxidsOf(vtxo);
+      if (candidates.length === 0) return "indeterminate";
+      const { txs } = await indexer.getVirtualTxs(candidates);
+      return classifyDepositSpend(
+        decodeOffer(import_base7.hex.decode(swap.offerHex)),
+        serverPubkey,
+        txs.map((psbt) => import_sdk7.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 spentTxid = vtxo.arkTxId || vtxo.spentBy;
+      if (!spentTxid) continue;
+      const swap = (await getAssetSwaps(repository)).find(
+        (s) => s.fundingTxid === vtxo.txid && s.swapPkScript === event.contractScript
+      );
+      if (!swap) continue;
+      const kind = await classify(swap, vtxo, spentTxid);
+      const changes = spendUpdate(swap, { txid: spentTxid, kind, at: event.timestamp });
+      if (!changes) continue;
+      const { persisted, swaps } = await updateAssetSwapBestEffort(
+        repository,
+        swap.id,
+        changes
+      );
+      if (!persisted) continue;
+      onUpdate?.({ ...swap, ...changes });
+      if (changes.status && RETIRABLE.includes(changes.status)) {
+        await retireOfferContract(manager, swaps, event.contractScript);
+      }
+    }
+  };
+  const unsubscribe = manager.onContractEvent((event) => {
+    if (event.type !== "vtxo_spent") return;
+    enqueue(() => handleSpend(event));
+  });
+  return {
+    stop: unsubscribe,
+    idle: () => queue
+  };
 }
 
 // src/rfq.ts
+var import_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");
 
 // src/claimPacket.ts
-var import_base6 = require("@scure/base");
+var import_base8 = require("@scure/base");
 var import_secp256k1 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
 var import_sha23 = require("@noble/hashes/sha2.js");
@@ -1393,15 +1761,29 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
   packet.set(ephemeralPub, 0);
   packet.set(nonce, 33);
   packet.set(sealed, 45);
-  return { ciphertext: import_base6.base64.encode(packet) };
+  return { ciphertext: import_base8.base64.encode(packet) };
 }
 
 // src/lockupContract.ts
-var import_base7 = require("@scure/base");
-var import_sdk7 = require("@arkade-os/sdk");
+var import_base9 = require("@scure/base");
+var import_sdk8 = require("@arkade-os/sdk");
 var SWAP_LOCKUP_CONTRACT_TYPE = "vhtlc-v2";
 var SWAP_LOCKUP_CONTRACT_LABEL = "Arkade RFQ swap lockup";
 var SWAP_LOCKUP_CONTRACT_KIND = "rfq-swap-lockup";
+var LockupContractMissing = class extends Error {
+  /** The lockup whose row is absent. */
+  address;
+  /** Its pkScript hex — the key the row would have been under. */
+  script;
+  constructor(address, script) {
+    super(
+      `no contract row for lockup ${address} (script ${script}); its covenant cannot be rebuilt from this wallet's contract store`
+    );
+    this.name = "LockupContractMissing";
+    this.address = address;
+    this.script = script;
+  }
+};
 var LockupRegistrationFailed = class extends Error {
   /** The lockup address that was never registered — never fund it: nothing
    * is watching it. */
@@ -1420,8 +1802,8 @@ async function registerLockupContract(contracts, script, address) {
   try {
     await contracts.createContract({
       type: SWAP_LOCKUP_CONTRACT_TYPE,
-      params: import_sdk7.VHTLCV2ContractHandler.serializeParams(script.options),
-      script: import_base7.hex.encode(script.pkScript),
+      params: import_sdk8.VHTLCV2ContractHandler.serializeParams(script.options),
+      script: import_base9.hex.encode(script.pkScript),
       address,
       label: SWAP_LOCKUP_CONTRACT_LABEL,
       metadata: { genericallySpendable: false, kind: SWAP_LOCKUP_CONTRACT_KIND }
@@ -1430,6 +1812,12 @@ async function registerLockupContract(contracts, script, address) {
     throw new LockupRegistrationFailed(script, address, error);
   }
 }
+async function lockupContractParams(contracts, lockupAddress) {
+  const script = import_base9.hex.encode(import_sdk8.ArkAddress.decode(lockupAddress).pkScript);
+  const [row] = await contracts.getContracts({ script });
+  if (!row) throw new LockupContractMissing(lockupAddress, script);
+  return row.params;
+}
 
 // src/rfq.ts
 var xOnly = (key, label) => {
@@ -1441,7 +1829,7 @@ var xOnly = (key, label) => {
 };
 var solverHex = (value, field) => {
   try {
-    return import_base8.hex.decode(value);
+    return import_base10.hex.decode(value);
   } catch {
     throw new Error(`solver sent malformed hex for ${field}`);
   }
@@ -1477,7 +1865,7 @@ var AddressMismatch = class extends Error {
     this.quoted = quoted;
   }
 };
-var newRfqId = () => import_base8.hex.encode(crypto.getRandomValues(new Uint8Array(32)));
+var newRfqId = () => import_base10.hex.encode(crypto.getRandomValues(new Uint8Array(32)));
 var lightningSendRequest = (input) => ({
   v: 1,
   type: "rfq_request",
@@ -1487,7 +1875,7 @@ var lightningSendRequest = (input) => ({
   profile: {
     invoice: input.invoice,
     refund_address: input.refundAddress,
-    client_refund_pubkey: import_base8.hex.encode(input.senderPubkey)
+    client_refund_pubkey: import_base10.hex.encode(input.senderPubkey)
   }
 });
 var arkadeSwapRequest = (input) => {
@@ -1734,11 +2122,11 @@ function lightningSendVtxoScript(params) {
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk8.VHTLC.ScriptV2({
+  return new import_sdk9.VHTLC.ScriptV2({
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
     server: params.serverPubkey,
-    preimageHash: (0, import_legacy2.ripemd160)(import_base8.hex.decode(params.paymentHash)),
+    preimageHash: (0, import_legacy2.ripemd160)(import_base10.hex.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
     unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
@@ -1757,10 +2145,10 @@ function lightningSendVtxoScript(params) {
 }
 async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk9.provisionRefundKey)(wallet);
+  const secrets = await (0, import_sdk10.provisionRefundKey)(wallet);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -1783,22 +2171,23 @@ 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 = xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key");
-  const network = (0, import_sdk8.getNetwork)(info.network);
-  const script = lightningSendVtxoScript({
-    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+  const serverPubkey = xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key");
+  const network = (0, import_sdk9.getNetwork)(info.network);
+  const treeParams = {
+    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
     serverPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk8.ArkAddress.decode(refundAddress).pkScript
-  });
+    refundPkScript: import_sdk9.ArkAddress.decode(refundAddress).pkScript
+  };
+  const script = lightningSendVtxoScript(treeParams);
   const address = script.address(network.hrp, serverPubkey).encode();
   verifyLockupAddress(quote, address);
   assertFundable({
@@ -1818,7 +2207,8 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     script,
     refundAddress,
     senderPubkey,
-    secrets
+    secrets,
+    treeParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -1837,9 +2227,9 @@ var onchainSendRequest = (input) => ({
   amount: input.amount,
   profile: {
     payment_hash: input.paymentHash,
-    payout_pubkey: import_base8.hex.encode(input.payoutPubkey),
+    payout_pubkey: import_base10.hex.encode(input.payoutPubkey),
     refund_address: input.refundAddress,
-    client_refund_pubkey: import_base8.hex.encode(input.senderPubkey)
+    client_refund_pubkey: import_base10.hex.encode(input.senderPubkey)
   }
 });
 var lightningReceiveRequest = (input) => ({
@@ -1852,7 +2242,7 @@ var lightningReceiveRequest = (input) => ({
   profile: {
     payment_hash: input.paymentHash,
     payout_address: input.payoutAddress,
-    payout_pubkey: import_base8.hex.encode(input.payoutPubkey),
+    payout_pubkey: import_base10.hex.encode(input.payoutPubkey),
     claim_packet: input.claimPacket
   }
 });
@@ -1866,9 +2256,9 @@ var onchainReceiveRequest = (input) => ({
   profile: {
     payment_hash: input.paymentHash,
     claim_packet: input.claimPacket,
-    refund_pubkey: import_base8.hex.encode(input.refundPubkey),
+    refund_pubkey: import_base10.hex.encode(input.refundPubkey),
     payout_address: input.payoutAddress,
-    payout_pubkey: import_base8.hex.encode(input.payoutPubkey)
+    payout_pubkey: import_base10.hex.encode(input.payoutPubkey)
   }
 });
 function deriveOnchainSend(input) {
@@ -1884,7 +2274,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1892,25 +2282,25 @@ function deriveOnchainSend(input) {
     emulatorPubkey: input.emulatorPubkey,
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk8.ArkAddress.decode(input.refundAddress).pkScript
+    refundPkScript: import_sdk9.ArkAddress.decode(input.refundAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
-  const htlc = onchainHtlcScript(
-    {
-      paymentHash: input.paymentHash,
-      claimKey: input.payoutPubkey,
-      refundKey: xOnly(import_base8.hex.decode(htlcPubkey), "solver L1 htlc key"),
-      refundLocktime: htlcLocktime
-    },
-    input.l1Network
-  );
+  const htlcParams = {
+    paymentHash: input.paymentHash,
+    claimKey: input.payoutPubkey,
+    refundKey: xOnly(import_base10.hex.decode(htlcPubkey), "solver L1 htlc key"),
+    refundLocktime: htlcLocktime
+  };
+  const htlc = onchainHtlcScript(htlcParams, input.l1Network);
   if (htlc.address !== htlcAddress) throw new AddressMismatch(htlc.address, htlcAddress);
   return {
     address,
     swapPkScript: script.pkScript,
     script,
     htlc,
+    htlcParams,
+    l1Network: input.l1Network,
     refundLocktime,
     htlcLocktime,
     minConfirmations
@@ -1918,16 +2308,16 @@ function deriveOnchainSend(input) {
 }
 async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk9.provisionClaimSecret)(wallet, { preimage: params.preimage });
+  const secrets = await (0, import_sdk10.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"
     );
   }
-  const paymentHash = import_base8.hex.encode(secrets.paymentHash);
+  const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -1941,14 +2331,14 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
       amountSide: params.amountSide
     })
   );
-  const network = (0, import_sdk8.getNetwork)(info.network);
+  const network = (0, import_sdk9.getNetwork)(info.network);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    serverPubkey: xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -1980,6 +2370,9 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     script: derived.script,
     refundAddress,
     htlc: derived.htlc,
+    htlcParams: derived.htlcParams,
+    l1Network: derived.l1Network,
+    minConfirmations: derived.minConfirmations,
     senderPubkey,
     secrets
   };
@@ -2056,11 +2449,11 @@ function receiveVtxoScript(params) {
     type: "seconds",
     value: BigInt(value)
   });
-  return new import_sdk8.VHTLC.ScriptV2({
+  return new import_sdk9.VHTLC.ScriptV2({
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
     server: params.serverPubkey,
-    preimageHash: (0, import_legacy2.ripemd160)(import_base8.hex.decode(params.paymentHash)),
+    preimageHash: (0, import_legacy2.ripemd160)(import_base10.hex.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
     unilateralRefundDelay: seconds(unilateralRefundDelay(params.claimDelay)),
@@ -2086,8 +2479,8 @@ function deriveLightningReceive(input) {
   if (refundLocktime === void 0 || invoice === void 0 || solverRefundPkScriptHex === void 0) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
-  const script = receiveVtxoScript({
-    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+  const treeParams = {
+    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2095,25 +2488,26 @@ function deriveLightningReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
-  });
+    payoutPkScript: import_sdk9.ArkAddress.decode(input.payoutAddress).pkScript
+  };
+  const script = receiveVtxoScript(treeParams);
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
-  return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime };
+  return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime, treeParams };
 }
 async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk9.provisionClaimSecret)(wallet);
+  const secrets = await (0, import_sdk10.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"
     );
   }
   const preimage = secrets.preimage;
-  const paymentHash = import_base8.hex.encode(secrets.paymentHash);
+  const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2132,15 +2526,15 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk8.getNetwork)(info.network);
+  const network = (0, import_sdk9.getNetwork)(info.network);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    serverPubkey: xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2171,7 +2565,8 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     script: derived.script,
     payoutAddress,
     payoutPubkey,
-    secrets
+    secrets,
+    treeParams: derived.treeParams
   };
 }
 function deriveOnchainReceive(input) {
@@ -2187,7 +2582,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly(import_base8.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2195,14 +2590,14 @@ function deriveOnchainReceive(input) {
     emulatorPubkey: input.emulatorPubkey,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
-    payoutPkScript: import_sdk8.ArkAddress.decode(input.payoutAddress).pkScript
+    payoutPkScript: import_sdk9.ArkAddress.decode(input.payoutAddress).pkScript
   });
   const address = script.address(input.hrp, input.serverPubkey).encode();
   verifyLockupAddress(quote, address);
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: xOnly(import_base8.hex.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: xOnly(import_base10.hex.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -2221,17 +2616,17 @@ function deriveOnchainReceive(input) {
 }
 async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk9.provisionClaimSecret)(wallet);
+  const secrets = await (0, import_sdk10.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"
     );
   }
   const preimage = secrets.preimage;
-  const paymentHash = import_base8.hex.encode(secrets.paymentHash);
+  const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk8.RestArkProvider(arkServerUrl).getInfo(),
+    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2251,16 +2646,16 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk8.getNetwork)(info.network);
+  const network = (0, import_sdk9.getNetwork)(info.network);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: xOnly(import_base8.hex.decode(info.signerPubkey), "ark signer key"),
+    serverPubkey: xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: xOnly(
-      import_base8.hex.decode((0, import_sdk8.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
+      import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
@@ -2297,15 +2692,15 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
 }
 
 // src/claim.ts
-var import_base10 = require("@scure/base");
+var import_base12 = require("@scure/base");
 var import_legacy3 = require("@noble/hashes/legacy.js");
 var import_sha25 = require("@noble/hashes/sha2.js");
-var import_sdk11 = require("@arkade-os/sdk");
+var import_sdk12 = require("@arkade-os/sdk");
 
 // src/refund.ts
-var import_base9 = require("@scure/base");
+var import_base11 = require("@scure/base");
 var import_sha24 = require("@noble/hashes/sha2.js");
-var import_sdk10 = require("@arkade-os/sdk");
+var import_sdk11 = 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"];
@@ -2352,7 +2747,7 @@ var LockupNeedsRecoveryError = class extends Error {
   }
 };
 async function findLockupVtxos(indexer, swapPkScript) {
-  const scripts = [import_base9.hex.encode(swapPkScript)];
+  const scripts = [import_base11.hex.encode(swapPkScript)];
   const [spendable, recoverable] = await Promise.all([
     indexer.getVtxos({ scripts, spendableOnly: true }),
     indexer.getVtxos({ scripts, recoverableOnly: true })
@@ -2377,28 +2772,33 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => import_base9.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => import_base11.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
-  ...(0, import_sdk10.getArkPsbtFields)(tx, inputIndex, import_sdk10.ConditionWitness).flat(),
+  ...(0, import_sdk11.getArkPsbtFields)(tx, inputIndex, import_sdk11.ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
 ];
 async function readLockupFate(indexer, input) {
-  const { vtxos } = await indexer.getVtxos({ scripts: [import_base9.hex.encode(input.swapPkScript)] });
+  const { vtxos } = await indexer.getVtxos({ scripts: [import_base11.hex.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
-  const spentBy = /* @__PURE__ */ new Set();
+  const spentBy = /* @__PURE__ */ new Map();
   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);
+    if (vtxo.spentBy)
+      spentBy.set(vtxo.spentBy, {
+        checkpointTxid: vtxo.spentBy,
+        arkTxid: vtxo.arkTxId
+      });
     else everySpendNamed = false;
   }
-  const { txs } = await indexer.getVirtualTxs([...spentBy]);
+  const spends = [...spentBy.values()];
+  const { txs } = await indexer.getVirtualTxs([...spentBy.keys()]);
   const observed = /* @__PURE__ */ new Set();
   for (const raw of txs) {
     let tx;
     try {
-      tx = import_sdk10.Transaction.fromPSBT(import_base9.base64.decode(raw));
+      tx = import_sdk11.Transaction.fromPSBT(import_base11.base64.decode(raw));
     } catch {
       continue;
     }
@@ -2406,16 +2806,16 @@ async function readLockupFate(indexer, input) {
     for (let i = 0; i < tx.inputsLength; i++) {
       const spent = tx.getInput(i);
       if (!spent.txid) continue;
-      const txid = import_base9.hex.encode(spent.txid);
+      const txid = import_base11.hex.encode(spent.txid);
       if (!all.some((vtxo) => vtxo.txid === txid && vtxo.vout === spent.index)) continue;
       for (const candidate of candidateWitnessItems(tx, i)) {
         if (hashesTo(candidate, input.paymentHash)) {
-          return { fate: "claimed", preimage: candidate };
+          return { fate: "claimed", preimage: candidate, spends };
         }
       }
     }
   }
-  return everySpendNamed && observed.size === spentBy.size ? { fate: "returned" } : { fate: "unknown" };
+  return everySpendNamed && observed.size === spentBy.size ? { fate: "returned", spends } : { fate: "unknown" };
 }
 async function pushRefundWithoutReceiver(ark, input) {
   if (input.vtxos.length === 0) throw new Error("nothing to refund: no funded outputs");
@@ -2435,14 +2835,14 @@ async function pushRefundWithoutReceiver(ark, input) {
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk10.CSVMultisigTapscript.decode(import_base9.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk11.CSVMultisigTapscript.decode(import_base11.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_sdk10.buildOffchainTx)(
+  const { arkTx, checkpoints } = (0, import_sdk11.buildOffchainTx)(
     input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -2455,18 +2855,18 @@ async function pushRefundWithoutReceiver(ark, input) {
   );
   const signedArkTx = await input.sender.sign(arkTx);
   const submitted = await ark.submitTx(
-    import_base9.base64.encode(signedArkTx.toPSBT()),
-    checkpoints.map((c) => import_base9.base64.encode(c.toPSBT()))
+    import_base11.base64.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => import_base11.base64.encode(c.toPSBT()))
   );
-  (0, import_sdk10.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
-  const matched = (0, import_sdk10.matchServerCheckpoints)(
+  (0, import_sdk11.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
+  const matched = (0, import_sdk11.matchServerCheckpoints)(
     submitted.signedCheckpointTxs,
     checkpoints,
     "refundWithoutReceiver"
   );
   const finalCheckpoints = await Promise.all(
     matched.map(
-      async ({ server }) => import_base9.base64.encode((await input.sender.sign(server, [0])).toPSBT())
+      async ({ server }) => import_base11.base64.encode((await input.sender.sign(server, [0])).toPSBT())
     )
   );
   await ark.finalizeTx(submitted.arkTxid, finalCheckpoints);
@@ -2546,20 +2946,20 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (import_base10.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base10.hex.encode(committed)) {
+  if (import_base12.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base12.hex.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk11.CSVMultisigTapscript.decode(import_base10.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk12.CSVMultisigTapscript.decode(import_base12.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_sdk11.signAndSubmitOffchainTx)({
-    identity: (0, import_sdk11.claimWithPreimageIdentity)(input.receiver, input.preimage),
+  const arkTxid = await (0, import_sdk12.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk12.claimWithPreimageIdentity)(input.receiver, input.preimage),
     provider: ark,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
@@ -2606,7 +3006,7 @@ async function claimReceiveLockup(indexer, ark, input) {
 }
 
 // src/refundBlocked.ts
-var import_sdk12 = require("@arkade-os/sdk");
+var import_sdk13 = require("@arkade-os/sdk");
 var RefundNotLocallyPossibleError = class extends Error {
   constructor(reason, message, options) {
     super(message, options);
@@ -2623,16 +3023,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
     );
   }
   try {
-    return await (0, import_sdk12.contractSigner)(wallet, record.signingDescriptor);
+    return await (0, import_sdk13.contractSigner)(wallet, record.signingDescriptor);
   } catch (cause) {
-    if (cause instanceof import_sdk12.WalletCannotSignError) {
+    if (cause instanceof import_sdk13.WalletCannotSignError) {
       throw new RefundNotLocallyPossibleError(
         "unsignable-wallet",
         `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
         { cause }
       );
     }
-    if (cause instanceof import_sdk12.ForeignDescriptorError) {
+    if (cause instanceof import_sdk13.ForeignDescriptorError) {
       throw new RefundNotLocallyPossibleError(
         "foreign-descriptor",
         `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -2643,10 +3043,31 @@ async function senderIdentityForSwapRecord(wallet, record) {
   }
 }
 
+// src/arkadeRefunder.ts
+function arkadeRefunder(deps) {
+  return async (swap) => {
+    const script = swap.lockup?.script;
+    if (!script) {
+      throw new Error(
+        `swap ${swap.rfqId} carries no lockup covenant, so its refund cannot be built`
+      );
+    }
+    const vtxos = await findLockupVtxos(deps.indexer, swap.lockupPkScript);
+    if (vtxos.length === 0) return null;
+    const record = await deps.repository.getRfqSwap(swap.rfqId);
+    if (!record) {
+      throw new RefundNotLocallyPossibleError(
+        "no-secrets",
+        `no stored record for ${swap.rfqId}; the descriptor that signs its refund lives there`
+      );
+    }
+    const sender = await senderIdentityForSwapRecord(deps.wallet, rfqSignerOf(record) ?? {});
+    return pushRefundWithoutReceiver(deps.ark, { script, sender, vtxos });
+  };
+}
+
 // src/swapManager.ts
-var import_base11 = require("@scure/base");
-var RFQ_SWAP_TERMINAL_STATES = ["settled", "refunded", "failed"];
-var isRfqSwapTerminal = (state) => RFQ_SWAP_TERMINAL_STATES.includes(state);
+var import_base13 = require("@scure/base");
 function nextOnchainAction(input) {
   switch (input.phase.phase) {
     case "unfunded":
@@ -2662,6 +3083,17 @@ function nextOnchainAction(input) {
       return input.htlcLocktime - input.now >= ONCHAIN_CLAIM_MARGIN_SECONDS ? "claim" : "claim_window_closed";
   }
 }
+var RfqSwapOriginRequired = class extends Error {
+  /** The swap that could not be admitted. */
+  rfqId;
+  constructor(rfqId) {
+    super(
+      `rfq swap ${rfqId} has no stored record and no origin was supplied; pass the request-time origin as addSwap's second argument so its first record can be written`
+    );
+    this.name = "RfqSwapOriginRequired";
+    this.rfqId = rfqId;
+  }
+};
 var notify = (listeners, call) => {
   for (const listener of listeners) {
     try {
@@ -2739,7 +3171,20 @@ var RfqSwapManager = class {
    * 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`. */
+  /**
+   * The request-time origin of each swap the manager may have to CREATE a
+   * record for, by rfqId.
+   *
+   * Needed only for a swap the store has never seen: once a record exists,
+   * `updateRfqSwapRecord` carries the origin half through and the map is
+   * redundant. It is kept anyway for the swap's whole life, so a record the
+   * store loses between passes is rewritten rather than lost — and dropped
+   * by {@link removeSwap} and by retention, which are the two places a swap
+   * stops being this manager's business.
+   */
+  origins = /* @__PURE__ */ new Map();
+  /** Records changed during the current pass, flushed to the repository and
+   * through `saveSwap`. */
   dirty = /* @__PURE__ */ new Set();
   /** Race guard: one action at a time per swap. */
   inProgress = /* @__PURE__ */ new Set();
@@ -2761,7 +3206,9 @@ var RfqSwapManager = class {
       this.actionExecutedListeners.add(config.events.onActionExecuted);
     }
   }
-  /** Wire the money-moving half. Without it the manager only watches. */
+  /** Wire the money-moving half. Without it the manager only watches. The
+   * two claims may be omitted for a consumer that drives no kind reaching
+   * them — see {@link AvailableRfqSwapManagerCallbacks}. */
   setCallbacks(callbacks) {
     this.callbacks = callbacks;
   }
@@ -2781,6 +3228,116 @@ var RfqSwapManager = class {
     this.actionExecutedListeners.add(listener);
     return () => this.actionExecutedListeners.delete(listener);
   }
+  /**
+   * Rebuild every stored swap and take over monitoring them.
+   *
+   * The composition a consumer otherwise writes by hand, and the one place
+   * all four pieces meet: retention decides what to keep
+   * (`shouldRetainRfqSwap`), the lockup's contract row supplies the covenant
+   * (`lockupContractParams`), `rebuildRfqSwap` turns a record back into a
+   * live swap, and each rebuilt swap arrives with its own origin, so nothing
+   * is asked of the caller.
+   *
+   * **Deliberately not part of {@link start}.** A consumer that wants to
+   * look at its records — count them, show them, prune and stop — is not
+   * forced to start driving money to do it. Call this first and `start()`
+   * after; a manager already running polls the restored swaps at once.
+   *
+   * Retention runs BEFORE the rebuild, so a record past
+   * `RFQ_SWAP_RETENTION_SECONDS` costs no contract lookup on its way to being
+   * dropped.
+   *
+   * **A record that cannot be rebuilt is reported, never swallowed and never
+   * fatal.** `rebuildRfqSwap` throws by design when the covenant params do
+   * not derive the funded address, and `lockupContractParams` throws
+   * `LockupContractMissing` when the wallet has no row for the lockup — both
+   * say something true about that one record, and neither is a reason to
+   * strand the others. They come back in {@link RfqRestoreResult.failed}.
+   */
+  async restoreFromRepository(options = {}) {
+    const repository = this.requireRepository("restoreFromRepository");
+    const params = options.params ?? this.paramsFromContracts();
+    const records = await repository.getAllRfqSwaps();
+    const pruned = await this.dropRetired(repository, records);
+    const retired = new Set(pruned);
+    const restored = [];
+    const failed = [];
+    for (const record of records) {
+      if (retired.has(record.rfqId)) continue;
+      let swap;
+      try {
+        swap = rebuildRfqSwap(record, await params(record));
+      } catch (error) {
+        failed.push({
+          rfqId: record.rfqId,
+          error: error instanceof Error ? error : new Error(errorMessage(error))
+        });
+        continue;
+      }
+      this.origins.set(record.rfqId, rfqSwapOriginOf(record));
+      if (isRfqSwapTerminal(swap.state)) this.finished.set(swap.rfqId, swap);
+      else this.track(swap);
+      restored.push(swap);
+    }
+    if (this.running) {
+      await Promise.allSettled(
+        restored.filter((swap) => this.monitored.has(swap.rfqId)).map((swap) => this.pollSwap(swap))
+      );
+    }
+    return { restored, failed, pruned };
+  }
+  /**
+   * Drop stored records that are terminal and past
+   * `RFQ_SWAP_RETENTION_SECONDS`, and return their ids.
+   *
+   * `needs_counterparty` is never dropped, however old: the money is still at
+   * the lockup and the counterparty's move still ends the swap. That rule
+   * lives in `shouldRetainRfqSwap`, which this defers to rather than
+   * restating.
+   *
+   * Public because retention is a caller's cadence, not the manager's: a
+   * long-lived process wants it on a timer of its own, a mobile app wants it
+   * at boot. {@link restoreFromRepository} runs it first, so the boot path
+   * needs no separate call.
+   */
+  async pruneRetiredSwaps() {
+    const repository = this.deps.repository;
+    if (!repository) return [];
+    return this.dropRetired(repository, await repository.getAllRfqSwaps());
+  }
+  async dropRetired(repository, records) {
+    const now = this.config.now();
+    const dropped = [];
+    for (const record of records) {
+      if (shouldRetainRfqSwap(record, now)) continue;
+      await repository.removeRfqSwap(record.rfqId);
+      this.finished.delete(record.rfqId);
+      if (!this.monitored.has(record.rfqId)) this.origins.delete(record.rfqId);
+      dropped.push(record.rfqId);
+    }
+    return dropped;
+  }
+  requireRepository(method) {
+    const repository = this.deps.repository;
+    if (!repository) {
+      throw new Error(
+        `${method} needs a record store; pass one as RfqSwapManagerDeps.repository`
+      );
+    }
+    return repository;
+  }
+  /** The default covenant source: the wallet's own contract row for each
+   * lockup, which is where registration put it before the address could be
+   * funded. */
+  paramsFromContracts() {
+    const contracts = this.deps.contracts;
+    if (!contracts) {
+      throw new Error(
+        "restoreFromRepository needs the covenant parameters: wire RfqSwapManagerDeps.contracts so each lockup's contract row can be read, or pass options.params"
+      );
+    }
+    return (record) => lockupContractParams(contracts, record.lockupAddress);
+  }
   /**
    * Load records and begin monitoring. Runs one pass immediately — a caller
    * resuming after a restart may be well past a deadline already — then
@@ -2790,8 +3347,17 @@ var RfqSwapManager = class {
    * 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.
+   *
+   * The signature is unchanged with a {@link RfqSwapManagerDeps.repository}
+   * wired; the origins are resolved from the store instead, by the same rule
+   * {@link addSwap} applies. A swap the store has never seen throws
+   * {@link RfqSwapOriginRequired} — hand that one to `addSwap` with its
+   * origin, or restore the whole set with {@link restoreFromRepository},
+   * which needs no caller input at all. Every swap is checked before any is
+   * tracked, so a bad one in the list does not leave a half-loaded manager.
    */
   async start(swaps = []) {
+    for (const swap of swaps) await this.admit(swap);
     for (const swap of swaps) {
       if (isRfqSwapTerminal(swap.state)) this.finished.set(swap.rfqId, swap);
       else this.track(swap);
@@ -2823,9 +3389,22 @@ var RfqSwapManager = class {
     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) {
+  /**
+   * Begin monitoring a swap. Polled immediately when the manager is running,
+   * so a just-funded swap does not wait out a whole interval.
+   *
+   * `origin` is the request-time half a live swap cannot carry — the corridor,
+   * the funded address, the corridor's profile, the funding txid — and it is
+   * what lets the manager write this swap's FIRST record. Supply it whenever
+   * a {@link RfqSwapManagerDeps.repository} is wired and the swap is new. It
+   * may be omitted for a swap the store already holds a record for, which is
+   * then read to confirm it; omitting it for one the store has never seen
+   * throws {@link RfqSwapOriginRequired} rather than admitting a swap whose
+   * record could never be written. With no repository wired the parameter is
+   * inert.
+   */
+  async addSwap(swap, origin) {
+    await this.admit(swap, origin);
     if (isRfqSwapTerminal(swap.state)) {
       this.finished.set(swap.rfqId, swap);
       return;
@@ -2833,6 +3412,29 @@ var RfqSwapManager = class {
     this.track(swap);
     if (this.running) await this.pollSwap(swap);
   }
+  /**
+   * Settle where this swap's record will come from, before it is monitored.
+   *
+   * Three ways it can be answered, in order: the caller passed an origin, one
+   * is already remembered from an earlier `addSwap`, or the store holds a
+   * record — which is the origin, already written. Only the last costs a read,
+   * and only when the first two are absent.
+   */
+  async admit(swap, origin) {
+    if (origin) {
+      assertSameSwap(origin, swap);
+      this.origins.set(swap.rfqId, origin);
+      if (this.deps.repository && !isRfqSwapTerminal(swap.state)) {
+        this.dirty.add(swap.rfqId);
+      }
+      return;
+    }
+    const repository = this.deps.repository;
+    if (!repository || this.origins.has(swap.rfqId)) return;
+    const stored = await repository.getRfqSwap(swap.rfqId);
+    if (!stored) throw new RfqSwapOriginRequired(swap.rfqId);
+    this.origins.set(swap.rfqId, rfqSwapOriginOf(stored));
+  }
   /** Forget a swap entirely, monitored or finished.
    *
    * Its contract row is left alone: registration is a wallet-level fact about
@@ -2850,6 +3452,7 @@ var RfqSwapManager = class {
     }
     this.waiters.delete(rfqId);
     this.dirty.delete(rfqId);
+    this.origins.delete(rfqId);
   }
   /** Every swap still being monitored. */
   async getPendingSwaps() {
@@ -2912,7 +3515,7 @@ var RfqSwapManager = class {
   // ── internals ────────────────────────────────────────────────────────────
   track(swap) {
     this.monitored.set(swap.rfqId, swap);
-    this.byLockupScript.set(import_base11.hex.encode(swap.lockupPkScript), swap);
+    this.byLockupScript.set(import_base13.hex.encode(swap.lockupPkScript), swap);
   }
   /** Drops the swap from BOTH indexes. The event index is the one that stops
    * a late event finding a swap that is gone; `pollSwap`'s own
@@ -2921,7 +3524,7 @@ var RfqSwapManager = class {
    * them from silently re-driving a cancelled swap. */
   untrack(rfqId) {
     const swap = this.monitored.get(rfqId);
-    if (swap) this.byLockupScript.delete(import_base11.hex.encode(swap.lockupPkScript));
+    if (swap) this.byLockupScript.delete(import_base13.hex.encode(swap.lockupPkScript));
     this.monitored.delete(rfqId);
     this.refundRefused.delete(rfqId);
     this.lastClaimError.delete(rfqId);
@@ -2983,7 +3586,7 @@ var RfqSwapManager = class {
     if (!lockup) {
       try {
         const [existing] = await contracts.getContracts({
-          script: import_base11.hex.encode(swap.lockupPkScript)
+          script: import_base13.hex.encode(swap.lockupPkScript)
         });
         if (existing) {
           this.registered.set(swap.rfqId, true);
@@ -3002,13 +3605,13 @@ var RfqSwapManager = class {
       );
       return;
     }
-    const script = import_base11.hex.encode(lockup.script.pkScript);
-    if (script !== import_base11.hex.encode(swap.lockupPkScript)) {
+    const script = import_base13.hex.encode(lockup.script.pkScript);
+    if (script !== import_base13.hex.encode(swap.lockupPkScript)) {
       this.registered.set(swap.rfqId, false);
       this.emitFailed(
         swap,
         new Error(
-          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${import_base11.hex.encode(swap.lockupPkScript)}`
+          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${import_base13.hex.encode(swap.lockupPkScript)}`
         )
       );
       return;
@@ -3027,7 +3630,7 @@ var RfqSwapManager = class {
    * script for its whole life. Best-effort — the swap is over either way. */
   retireContract(swap) {
     if (!this.deps.contracts || !this.registered.get(swap.rfqId)) return;
-    void this.deps.contracts.setContractWatchState(import_base11.hex.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
+    void this.deps.contracts.setContractWatchState(import_base13.hex.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
   }
   arm() {
     if (!this.running) return;
@@ -3065,6 +3668,7 @@ var RfqSwapManager = class {
       fate = { fate: "unknown" };
     }
     if (fate.fate === "claimed" || fate.fate === "returned") {
+      this.stampLockupSpends(swap, fate.spends);
       this.setState(swap, fate.fate === "claimed" ? "settled" : "refunded");
       return;
     }
@@ -3149,10 +3753,10 @@ var RfqSwapManager = class {
         );
       }
     }
-    if (!this.callbacks) {
+    if (!this.callbacks || !this.callbacks.claimLockup) {
       return this.block(
         swap,
-        "no callbacks are wired, so this wallet cannot claim the lockup"
+        this.callbacks ? "no claimLockup callback is wired, so this wallet cannot claim the lockup" : "no callbacks are wired, so this wallet cannot claim the lockup"
       );
     }
     this.setState(swap, "claimable");
@@ -3202,8 +3806,15 @@ var RfqSwapManager = class {
     });
     if (action === "claim" && phase.phase === "claimable") {
       if (swap.claimTxid) return "continue";
+      if (this.callbacks && !this.callbacks.claimOnchain) {
+        this.block(
+          swap,
+          "no claimOnchain callback is wired, so this wallet cannot claim the L1 fill"
+        );
+        return "handled";
+      }
       this.setOnchainState(swap, "claimable");
-      if (!this.config.enableAutoActions || !this.callbacks) return "handled";
+      if (!this.config.enableAutoActions || !this.callbacks?.claimOnchain) return "handled";
       try {
         const { txid } = await this.callbacks.claimOnchain(swap, phase.utxo);
         swap.claimTxid = txid;
@@ -3316,6 +3927,24 @@ var RfqSwapManager = class {
     if (swap.state !== "needs_counterparty") return;
     this.setState(swap, traderClaimTxid(swap) ? "claimed" : "pending");
   }
+  /**
+   * Record which ark transactions ended the lockup.
+   *
+   * Only the ones the indexer actually named: `LockupSpend.arkTxid` is
+   * optional, and a checkpoint txid is not what history correlates on — a
+   * record carrying one would name a transaction the wallet's own activity
+   * never shows. Fewer txids is the right failure here.
+   *
+   * Assigned rather than merged: the fate is one read of the whole lockup,
+   * so it is the complete answer for this swap, and a swap only reaches a
+   * verdict once.
+   */
+  stampLockupSpends(swap, spends) {
+    const arkTxids = spends.map((spend) => spend.arkTxid).filter((txid) => txid !== void 0);
+    if (arkTxids.length === 0) return;
+    swap.lockupSpendArkTxids = arkTxids;
+    this.touch(swap);
+  }
   touch(swap) {
     swap.updatedAt = this.config.now();
     this.dirty.add(swap.rfqId);
@@ -3341,9 +3970,29 @@ var RfqSwapManager = class {
   emitAction(swap, action) {
     notify(this.actionExecutedListeners, (listener) => listener(swap, action));
   }
-  /** Whether the record is now persisted — false only when `saveSwap` threw. */
+  /**
+   * Flush a changed record to every sink that is wired, and say whether all
+   * of them took it.
+   *
+   * Up to two writes, in this order: the canonical `RfqSwapRecord` to
+   * {@link RfqSwapManagerDeps.repository}, then
+   * {@link RfqSwapManagerCallbacks.saveSwap}. Both gate — a rejection from
+   * either leaves the record dirty and monitored, so waiters stay unsettled
+   * and a terminal swap is not finalized until the write it claims lands.
+   * That is exactly today's rule for `saveSwap`, applied to whichever sinks
+   * exist; wiring the repository does not weaken it.
+   *
+   * The canonical write goes FIRST and a failure there skips the second.
+   * `saveSwap` is a projection of the record, and projecting a state the
+   * record of record has just refused would leave the secondary sink ahead
+   * of the primary — the one ordering that survives no restart.
+   *
+   * With neither wired the state is process-local, which is what a manager
+   * with no callbacks has always done.
+   */
   async save(swap) {
-    if (!this.callbacks) return true;
+    if (!await this.saveRecord(swap)) return false;
+    if (!this.callbacks?.saveSwap) return true;
     try {
       await this.callbacks.saveSwap(swap);
       return true;
@@ -3352,6 +4001,25 @@ var RfqSwapManager = class {
       return false;
     }
   }
+  /** The canonical write. True when there is no repository to write to. */
+  async saveRecord(swap) {
+    const repository = this.deps.repository;
+    if (!repository) return true;
+    try {
+      const stored = await repository.getRfqSwap(swap.rfqId);
+      const record = stored ? updateRfqSwapRecord(stored, swap) : createRfqSwapRecord(this.originOrThrow(swap), swap);
+      await repository.saveRfqSwap(record);
+      return true;
+    } catch (error) {
+      this.emitFailed(swap, error);
+      return false;
+    }
+  }
+  originOrThrow(swap) {
+    const origin = this.origins.get(swap.rfqId);
+    if (!origin) throw new RfqSwapOriginRequired(swap.rfqId);
+    return origin;
+  }
   /**
    * Drop a terminal swap from monitoring and report it exactly once.
    *
@@ -3411,6 +4079,8 @@ var errorMessage = (error) => error instanceof Error ? error.message : String(er
 var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 
 // src/activity.ts
+var import_sdk14 = require("@arkade-os/sdk");
+var import_base14 = require("@scure/base");
 var LABELS = {
   lightning_send: "Lightning send",
   lightning_receive: "Lightning receive",
@@ -3463,6 +4133,44 @@ function swapActivityResolver(deps) {
     }
   };
 }
+async function rfqSwapActivityInputs(deps) {
+  const records = await deps.repository.getAllRfqSwaps();
+  return Promise.all(records.map((record) => activityInputOf(record, deps.indexer)));
+}
+async function activityInputOf(record, indexer) {
+  const txids = /* @__PURE__ */ new Set();
+  if (record.fundingArkTxid) txids.add(record.fundingArkTxid);
+  if (record.refundArkTxid) txids.add(record.refundArkTxid);
+  const handler = rfqCorridorHandlers.getOrThrow(record.kind);
+  for (const txid of handler.activityTxids?.(record.profile) ?? []) txids.add(txid);
+  for (const txid of record.lockupSpendArkTxids ?? []) txids.add(txid);
+  const spendUnknown = isRfqSwapTerminal(record.state) && !record.refundArkTxid && !record.lockupSpendArkTxids?.length;
+  if (indexer && (!record.fundingArkTxid || spendUnknown)) {
+    for (const txid of await lockupTxids(indexer, record, !record.fundingArkTxid)) {
+      txids.add(txid);
+    }
+  }
+  return { rfqId: record.rfqId, kind: record.kind, state: record.state, txids: [...txids] };
+}
+async function lockupTxids(indexer, record, wantFunding) {
+  let script;
+  try {
+    script = import_base14.hex.encode(import_sdk14.ArkAddress.decode(record.lockupAddress).pkScript);
+  } catch {
+    return [];
+  }
+  try {
+    const { vtxos } = await indexer.getVtxos({ scripts: [script] });
+    const out = [];
+    for (const vtxo of vtxos ?? []) {
+      if (wantFunding) out.push(vtxo.txid);
+      if (vtxo.arkTxId) out.push(vtxo.arkTxId);
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ARKADE_ASSET,
@@ -3475,6 +4183,7 @@ function swapActivityResolver(deps) {
   LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR,
   LockupAmountMismatchError,
+  LockupContractMissing,
   LockupNeedsRecoveryError,
   LockupRegistrationFailed,
   MAX_MIN_CONFIRMATIONS,
@@ -3492,10 +4201,12 @@ function swapActivityResolver(deps) {
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
   RFQ_RESOLVED_STATES,
+  RFQ_SWAP_RETENTION_SECONDS,
   RFQ_SWAP_TERMINAL_STATES,
   RFQ_TERMINAL_STATES,
   RefundNotLocallyPossibleError,
   RfqSwapManager,
+  RfqSwapOriginRequired,
   SOLO_REFUND_HEADROOM_SECONDS,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
@@ -3503,6 +4214,7 @@ function swapActivityResolver(deps) {
   SwapRefusal,
   addAssetSwap,
   arkadeAssetLeg,
+  arkadeRefunder,
   arkadeSwapRequest,
   assertFundable,
   assertReceivable,
@@ -3518,6 +4230,7 @@ function swapActivityResolver(deps) {
   classifyOnchainHtlc,
   classifySpend,
   createOffer,
+  createRfqSwapRecord,
   decodeOffer,
   deriveLightningReceive,
   deriveOnchainReceive,
@@ -3535,6 +4248,7 @@ function swapActivityResolver(deps) {
   lightningReceiveRequest,
   lightningSendRequest,
   lightningSendVtxoScript,
+  lockupContractParams,
   makeCachedFeedFetch,
   newPreimage,
   newRfqId,
@@ -3543,12 +4257,14 @@ function swapActivityResolver(deps) {
   offerVtxoScript,
   onchainHtlcScript,
   onchainReceiveRequest,
+  onchainSendProfile,
   onchainSendRequest,
   paymentHashOf,
   preimageForSwapRecord,
   pushClaim,
   pushRefundWithoutReceiver,
   readLockupFate,
+  rebuildRfqSwap,
   receiveVtxoScript,
   refundIfUnresolved,
   registerLockupContract,
@@ -3559,9 +4275,15 @@ function swapActivityResolver(deps) {
   requestOnchainSend,
   restoreAssetSwaps,
   retireSettledOfferContracts,
+  rfqClaimSecretOf,
   rfqPair,
+  rfqSecretsProfile,
+  rfqSignerOf,
+  rfqSwapActivityInputs,
+  rfqSwapOriginOf,
   sealClaimPacket,
   senderIdentityForSwapRecord,
+  shouldRetainRfqSwap,
   spendTxidsOf,
   spendUpdate,
   swapActivityResolver,
@@ -3572,6 +4294,7 @@ function swapActivityResolver(deps) {
   unilateralRefundWithoutReceiverDelay,
   updateAssetSwap,
   updateAssetSwapBestEffort,
+  updateRfqSwapRecord,
   validatePlan,
   verifyLockupAddress,
   verifyReceiveInvoice,