@arkade-os/swap 0.0.6 → 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,16 +58,20 @@ __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,
   SWAP_LOCKUP_CONTRACT_TYPE: () => SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal: () => SwapRefusal,
   addAssetSwap: () => addAssetSwap,
+  arkadeAssetLeg: () => arkadeAssetLeg,
+  arkadeRefunder: () => arkadeRefunder,
   arkadeSwapRequest: () => arkadeSwapRequest,
   assertFundable: () => assertFundable,
   assertReceivable: () => assertReceivable,
@@ -82,6 +87,7 @@ __export(index_exports, {
   classifyOnchainHtlc: () => classifyOnchainHtlc,
   classifySpend: () => classifySpend,
   createOffer: () => createOffer,
+  createRfqSwapRecord: () => createRfqSwapRecord,
   decodeOffer: () => decodeOffer,
   deriveLightningReceive: () => deriveLightningReceive,
   deriveOnchainReceive: () => deriveOnchainReceive,
@@ -99,6 +105,7 @@ __export(index_exports, {
   lightningReceiveRequest: () => lightningReceiveRequest,
   lightningSendRequest: () => lightningSendRequest,
   lightningSendVtxoScript: () => lightningSendVtxoScript,
+  lockupContractParams: () => lockupContractParams,
   makeCachedFeedFetch: () => makeCachedFeedFetch,
   newPreimage: () => newPreimage,
   newRfqId: () => newRfqId,
@@ -107,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,
@@ -123,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,
@@ -136,6 +151,7 @@ __export(index_exports, {
   unilateralRefundWithoutReceiverDelay: () => unilateralRefundWithoutReceiverDelay,
   updateAssetSwap: () => updateAssetSwap,
   updateAssetSwapBestEffort: () => updateAssetSwapBestEffort,
+  updateRfqSwapRecord: () => updateRfqSwapRecord,
   validatePlan: () => validatePlan,
   verifyLockupAddress: () => verifyLockupAddress,
   verifyReceiveInvoice: () => verifyReceiveInvoice,
@@ -761,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) {
@@ -771,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);
   }
@@ -785,6 +814,7 @@ var InMemoryAssetSwapRepository = class {
   }
   async clear() {
     this.swaps.clear();
+    this.rfqSwaps.clear();
     this.scanned.clear();
     this.markets.clear();
   }
@@ -795,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;
   }
@@ -856,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) {
@@ -869,33 +901,578 @@ 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) => {
       store.put(entry, marketsCacheKey(network, registry));
     });
   }
-  /** All stores in one transaction: clearing swaps but keeping scanned txids
-   * would leave the restore scan permanently skipping those funding txs, so
-   * a partial clear must not be observable. */
-  async clear() {
-    const stores = STORES.map(([name]) => name);
-    const tx = (await this.ensureDb()).transaction(stores, "readwrite");
-    const done = txDone(tx);
-    for (const name of stores) tx.objectStore(name).clear();
-    await done;
+  /** All stores in one transaction: clearing swaps but keeping scanned txids
+   * would leave the restore scan permanently skipping those funding txs, so
+   * a partial clear must not be observable. */
+  async clear() {
+    const stores = STORES.map(([name]) => name);
+    const tx = (await this.ensureDb()).transaction(stores, "readwrite");
+    const done = (0, import_sdk4.awaitTransaction)(tx);
+    for (const name of stores) tx.objectStore(name).clear();
+    await done;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.connection[Symbol.asyncDispose]();
+  }
+};
+
+// 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);
+  }
+  /** 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);
+  }
+  /**
+   * 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;
+  }
+  has(kind) {
+    return this.handlers.has(kind);
+  }
+  registeredKinds() {
+    return [...this.handlers.keys()];
+  }
+  /** Test seam, mirroring the contract registry's. */
+  unregister(kind) {
+    return this.handlers.delete(kind);
+  }
+};
+var rfqCorridorHandlers = new RfqCorridorRegistry();
+
+// src/rfqProfileParts.ts
+var rfqSecretsProfile = (secrets, paymentHash) => {
+  const { signingDescriptor, ...preimage } = swapSecretsToRecord(secrets);
+  return {
+    signer: { signingDescriptor },
+    ...paymentHash ? { hashlock: { paymentHash, ...preimage } } : {}
+  };
+};
+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")
+  };
+  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_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);
+var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
+var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
+var MAX_MIN_CONFIRMATIONS = 6;
+var ONCHAIN_SECONDS_PER_BLOCK = 600;
+var ONCHAIN_DUST_SATS = BigInt(330);
+var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
+var paymentHashOf = (preimage) => import_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,
+  regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
+};
+function onchainHtlcScript(params, network) {
+  if (params.claimKey.length !== 32 || params.refundKey.length !== 32) {
+    throw new Error("claimKey and refundKey must be 32-byte x-only keys");
+  }
+  if (!Number.isInteger(params.refundLocktime) || params.refundLocktime <= 0) {
+    throw new Error(
+      `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
+    );
+  }
+  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",
+    32,
+    "EQUALVERIFY",
+    "HASH160",
+    h160,
+    "EQUALVERIFY",
+    params.claimKey,
+    "CHECKSIG"
+  ]);
+  const refund = btc.Script.encode([
+    btc.ScriptNum().encode(BigInt(params.refundLocktime)),
+    "CHECKLOCKTIMEVERIFY",
+    "DROP",
+    params.refundKey,
+    "CHECKSIG"
+  ]);
+  const payment = btc.p2tr(
+    btc.TAPROOT_UNSPENDABLE_KEY,
+    btc.taprootListToTree([{ script: claim }, { script: refund }]),
+    L1_NETWORKS[network],
+    true
+  );
+  const controlBlockFor = (leaf) => {
+    for (const [block, script] of payment.tapLeafScript ?? []) {
+      if (script.length - 1 === leaf.length && import_base3.hex.encode(script.subarray(0, leaf.length)) === import_base3.hex.encode(leaf)) {
+        return btc.TaprootControlBlock.encode(block);
+      }
+    }
+    throw new Error("leaf missing from compiled taproot tree");
+  };
+  return {
+    address: payment.address,
+    pkScript: payment.script,
+    leaves: { claim, refund },
+    controlBlocks: { claim: controlBlockFor(claim), refund: controlBlockFor(refund) },
+    paymentHash: params.paymentHash,
+    refundLocktime: params.refundLocktime
+  };
+}
+var buildLeafSpend = async (input) => {
+  if (!Number.isFinite(input.feeRateSatVb) || input.feeRateSatVb <= 0) {
+    throw new Error(`feeRateSatVb must be positive, got ${input.feeRateSatVb}`);
+  }
+  const assemble = (payout2) => {
+    const tx2 = new btc.Transaction({ lockTime: input.lockTime ?? 0 });
+    tx2.addInput({
+      txid: input.utxo.txid,
+      index: input.utxo.vout,
+      witnessUtxo: { script: input.htlc.pkScript, amount: input.utxo.amount },
+      sequence: input.sequence
+    });
+    tx2.addOutput({ script: input.payoutPkScript, amount: payout2 });
+    return tx2;
+  };
+  const witness = (sig2) => [
+    sig2,
+    ...input.stackAboveSig,
+    input.leaf,
+    input.controlBlock
+  ];
+  const sizing = assemble(input.utxo.amount);
+  sizing.updateInput(0, { finalScriptWitness: witness(new Uint8Array(64)) }, true);
+  const fee = BigInt(Math.ceil(sizing.vsize * input.feeRateSatVb));
+  const payout = input.utxo.amount - fee;
+  if (payout < ONCHAIN_DUST_SATS) {
+    throw new Error(
+      `fee ${fee} leaves ${payout} sats from a ${input.utxo.amount} sat HTLC \u2014 below the ${ONCHAIN_DUST_SATS} sat dust limit`
+    );
+  }
+  const tx = assemble(payout);
+  const sighash = tx.preimageWitnessV1(
+    0,
+    [input.htlc.pkScript],
+    btc.SigHash.DEFAULT,
+    [input.utxo.amount],
+    void 0,
+    input.leaf,
+    192
+  );
+  const sig = await input.sign(sighash);
+  if (sig.length !== 64)
+    throw new Error(`sign() must return a 64-byte BIP340 signature, got ${sig.length}`);
+  tx.updateInput(0, { finalScriptWitness: witness(sig) }, true);
+  return { txHex: tx.hex, txid: tx.id, payoutAmount: payout };
+};
+var buildHtlcClaim = async (input) => {
+  if (paymentHashOf(input.preimage) !== input.htlc.paymentHash) {
+    throw new Error("preimage does not hash to the HTLC's payment hash");
+  }
+  return buildLeafSpend({
+    htlc: input.htlc,
+    utxo: input.utxo,
+    leaf: input.htlc.leaves.claim,
+    controlBlock: input.htlc.controlBlocks.claim,
+    stackAboveSig: [input.preimage],
+    payoutPkScript: input.payoutPkScript,
+    feeRateSatVb: input.feeRateSatVb,
+    sign: input.sign,
+    sequence: 4294967293
+  });
+};
+var buildHtlcRefund = (input) => buildLeafSpend({
+  htlc: input.htlc,
+  utxo: input.utxo,
+  leaf: input.htlc.leaves.refund,
+  controlBlock: input.htlc.controlBlocks.refund,
+  stackAboveSig: [],
+  payoutPkScript: input.payoutPkScript,
+  feeRateSatVb: input.feeRateSatVb,
+  sign: input.sign,
+  lockTime: input.htlc.refundLocktime,
+  // any value below 0xffffffff enables nLockTime enforcement
+  sequence: 4294967294
+});
+function extractPreimage(txHex, paymentHash) {
+  let raw;
+  try {
+    raw = btc.RawTx.decode(import_base3.hex.decode(txHex));
+  } catch {
+    return null;
+  }
+  for (const stack of raw.witnesses ?? []) {
+    for (const item of stack) {
+      if (item.length === 32 && import_base3.hex.encode((0, import_sha22.sha256)(item)) === paymentHash) return item;
+    }
+  }
+  return null;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function awaitOnchainFill(chain, htlc, minConfirmations, options = {}) {
+  const pollMs = options.pollMs ?? 5e3;
+  for (; ; ) {
+    const utxos = await chain.getScriptUtxos(htlc.pkScript);
+    const eligible = utxos.filter((u) => u.confirmations >= minConfirmations).sort((a, b) => b.amount > a.amount ? 1 : -1);
+    if (eligible[0]) return eligible[0];
+    if (options.deadline !== void 0 && Date.now() / 1e3 >= options.deadline) {
+      const error = new Error("HTLC was not filled before the deadline");
+      error.reason = "fill_timeout";
+      throw error;
+    }
+    await sleep(pollMs);
+  }
+}
+async function claimOnchainFill(chain, input) {
+  const now = input.now ?? Math.floor(Date.now() / 1e3);
+  if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
+    const error = new Error(
+      "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
+    );
+    error.reason = "claim_window_closed";
+    throw error;
+  }
+  const spend = await buildHtlcClaim(input);
+  const txid = await chain.broadcast(spend.txHex);
+  return { txid, payoutAmount: spend.payoutAmount };
+}
+async function classifyOnchainHtlc(chain, input) {
+  const utxos = await chain.getScriptUtxos(input.htlc.pkScript);
+  const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
+  if (!best) {
+    if (!input.funding) return { phase: "unfunded" };
+    const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
+    if (!spend) return { phase: "unfunded" };
+    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
+    const txid = btc.Transaction.fromRaw(import_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`
+    );
   }
-  async [Symbol.asyncDispose]() {
-    if (!this.dbPromise) return;
-    await (0, import_sdk4.closeDatabase)(this.dbName);
-    this.dbPromise = null;
+}
+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_base3 = require("@scure/base");
-var import_sdk5 = require("@arkade-os/sdk");
+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();
@@ -911,7 +1488,7 @@ async function fetchParsedTxs(indexer, txids) {
     if (result.status !== "fulfilled") continue;
     for (const psbt of result.value) {
       try {
-        const parsed = import_sdk5.Transaction.fromPSBT(import_base3.base64.decode(psbt));
+        const parsed = import_sdk6.Transaction.fromPSBT(import_base6.base64.decode(psbt));
         parsedByTxid.set(parsed.id, parsed);
       } catch {
       }
@@ -926,7 +1503,7 @@ 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";
+    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
@@ -937,11 +1514,11 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
   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;
+    if (import_base6.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";
+      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";
@@ -970,19 +1547,19 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
     if (!fundingTx) continue;
     fetchedTxids.push(txid);
     try {
-      const packet = import_sdk5.Extension.fromTx(parsed).getPacketByType(OFFER_PACKET_TYPE);
+      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_base3.hex.encode(payload)
+        offerHex: import_base6.hex.encode(payload)
       });
     } catch {
     }
   }
   if (found.length === 0) return { restored: [], scannedTxids: fetchedTxids };
-  const scripts = [...new Set(found.map((f) => import_base3.hex.encode(f.offer.swapPkScript)))];
+  const 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();
@@ -994,7 +1571,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
   const spendTxids = /* @__PURE__ */ new Set();
   for (const { fundingTx, offer } of found) {
     const vtxo = vtxoByScriptAndTxid.get(
-      `${import_base3.hex.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
+      `${import_base6.hex.encode(offer.swapPkScript)}:${fundingTx.redeemTxid}`
     );
     if (vtxo?.virtualStatus.state !== "spent") continue;
     for (const txid of spendTxidsOf(vtxo)) spendTxids.add(txid);
@@ -1003,7 +1580,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
   const restored = [];
   const unresolved = /* @__PURE__ */ new Set();
   for (const { fundingTx, offer, offerHex } of found) {
-    const swapPkScript = import_base3.hex.encode(offer.swapPkScript);
+    const swapPkScript = import_base6.hex.encode(offer.swapPkScript);
     const vtxo = vtxoByScriptAndTxid.get(`${swapPkScript}:${fundingTx.redeemTxid}`);
     if (!vtxo) {
       unresolved.add(fundingTx.redeemTxid);
@@ -1060,8 +1637,8 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 }
 
 // src/watch.ts
-var import_base4 = require("@scure/base");
-var import_sdk6 = require("@arkade-os/sdk");
+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;
@@ -1081,8 +1658,8 @@ async function watchOfferSwaps({
   onUpdate
 }) {
   const manager = await wallet.getContractManager();
-  const serverPubkey = import_sdk6.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
-  const indexer = new import_sdk6.RestIndexerProvider(arkServerUrl);
+  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(() => {
@@ -1090,270 +1667,62 @@ async function watchOfferSwaps({
   };
   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
-  };
-}
-
-// src/rfq.ts
-var import_base8 = require("@scure/base");
-var import_legacy2 = require("@noble/hashes/legacy.js");
-var import_sdk8 = require("@arkade-os/sdk");
-
-// src/onchainHtlc.ts
-var import_base5 = 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);
-var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
-var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
-var MAX_MIN_CONFIRMATIONS = 6;
-var ONCHAIN_SECONDS_PER_BLOCK = 600;
-var ONCHAIN_DUST_SATS = BigInt(330);
-var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
-var paymentHashOf = (preimage) => import_base5.hex.encode((0, import_sha22.sha256)(preimage));
-var h160FromPaymentHash = (paymentHash) => (0, import_legacy.ripemd160)(import_base5.hex.decode(paymentHash));
-var L1_NETWORKS = {
-  bitcoin: btc.NETWORK,
-  testnet: btc.TEST_NETWORK,
-  regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
-};
-function onchainHtlcScript(params, network) {
-  if (params.claimKey.length !== 32 || params.refundKey.length !== 32) {
-    throw new Error("claimKey and refundKey must be 32-byte x-only keys");
-  }
-  if (!Number.isInteger(params.refundLocktime) || params.refundLocktime <= 0) {
-    throw new Error(
-      `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
-    );
-  }
-  const h160 = h160FromPaymentHash(params.paymentHash);
-  const claim = btc.Script.encode([
-    "SIZE",
-    32,
-    "EQUALVERIFY",
-    "HASH160",
-    h160,
-    "EQUALVERIFY",
-    params.claimKey,
-    "CHECKSIG"
-  ]);
-  const refund = btc.Script.encode([
-    btc.ScriptNum().encode(BigInt(params.refundLocktime)),
-    "CHECKLOCKTIMEVERIFY",
-    "DROP",
-    params.refundKey,
-    "CHECKSIG"
-  ]);
-  const payment = btc.p2tr(
-    btc.TAPROOT_UNSPENDABLE_KEY,
-    btc.taprootListToTree([{ script: claim }, { script: refund }]),
-    L1_NETWORKS[network],
-    true
-  );
-  const controlBlockFor = (leaf) => {
-    for (const [block, script] of payment.tapLeafScript ?? []) {
-      if (script.length - 1 === leaf.length && import_base5.hex.encode(script.subarray(0, leaf.length)) === import_base5.hex.encode(leaf)) {
-        return btc.TaprootControlBlock.encode(block);
-      }
-    }
-    throw new Error("leaf missing from compiled taproot tree");
-  };
-  return {
-    address: payment.address,
-    pkScript: payment.script,
-    leaves: { claim, refund },
-    controlBlocks: { claim: controlBlockFor(claim), refund: controlBlockFor(refund) },
-    paymentHash: params.paymentHash,
-    refundLocktime: params.refundLocktime
-  };
-}
-var buildLeafSpend = async (input) => {
-  if (!Number.isFinite(input.feeRateSatVb) || input.feeRateSatVb <= 0) {
-    throw new Error(`feeRateSatVb must be positive, got ${input.feeRateSatVb}`);
-  }
-  const assemble = (payout2) => {
-    const tx2 = new btc.Transaction({ lockTime: input.lockTime ?? 0 });
-    tx2.addInput({
-      txid: input.utxo.txid,
-      index: input.utxo.vout,
-      witnessUtxo: { script: input.htlc.pkScript, amount: input.utxo.amount },
-      sequence: input.sequence
-    });
-    tx2.addOutput({ script: input.payoutPkScript, amount: payout2 });
-    return tx2;
-  };
-  const witness = (sig2) => [
-    sig2,
-    ...input.stackAboveSig,
-    input.leaf,
-    input.controlBlock
-  ];
-  const sizing = assemble(input.utxo.amount);
-  sizing.updateInput(0, { finalScriptWitness: witness(new Uint8Array(64)) }, true);
-  const fee = BigInt(Math.ceil(sizing.vsize * input.feeRateSatVb));
-  const payout = input.utxo.amount - fee;
-  if (payout < ONCHAIN_DUST_SATS) {
-    throw new Error(
-      `fee ${fee} leaves ${payout} sats from a ${input.utxo.amount} sat HTLC \u2014 below the ${ONCHAIN_DUST_SATS} sat dust limit`
-    );
-  }
-  const tx = assemble(payout);
-  const sighash = tx.preimageWitnessV1(
-    0,
-    [input.htlc.pkScript],
-    btc.SigHash.DEFAULT,
-    [input.utxo.amount],
-    void 0,
-    input.leaf,
-    192
-  );
-  const sig = await input.sign(sighash);
-  if (sig.length !== 64)
-    throw new Error(`sign() must return a 64-byte BIP340 signature, got ${sig.length}`);
-  tx.updateInput(0, { finalScriptWitness: witness(sig) }, true);
-  return { txHex: tx.hex, txid: tx.id, payoutAmount: payout };
-};
-var buildHtlcClaim = async (input) => {
-  if (paymentHashOf(input.preimage) !== input.htlc.paymentHash) {
-    throw new Error("preimage does not hash to the HTLC's payment hash");
-  }
-  return buildLeafSpend({
-    htlc: input.htlc,
-    utxo: input.utxo,
-    leaf: input.htlc.leaves.claim,
-    controlBlock: input.htlc.controlBlocks.claim,
-    stackAboveSig: [input.preimage],
-    payoutPkScript: input.payoutPkScript,
-    feeRateSatVb: input.feeRateSatVb,
-    sign: input.sign,
-    sequence: 4294967293
-  });
-};
-var buildHtlcRefund = (input) => buildLeafSpend({
-  htlc: input.htlc,
-  utxo: input.utxo,
-  leaf: input.htlc.leaves.refund,
-  controlBlock: input.htlc.controlBlocks.refund,
-  stackAboveSig: [],
-  payoutPkScript: input.payoutPkScript,
-  feeRateSatVb: input.feeRateSatVb,
-  sign: input.sign,
-  lockTime: input.htlc.refundLocktime,
-  // any value below 0xffffffff enables nLockTime enforcement
-  sequence: 4294967294
-});
-function extractPreimage(txHex, paymentHash) {
-  let raw;
-  try {
-    raw = btc.RawTx.decode(import_base5.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;
+    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";
     }
-  }
-  return null;
-}
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function awaitOnchainFill(chain, htlc, minConfirmations, options = {}) {
-  const pollMs = options.pollMs ?? 5e3;
-  for (; ; ) {
-    const utxos = await chain.getScriptUtxos(htlc.pkScript);
-    const eligible = utxos.filter((u) => u.confirmations >= minConfirmations).sort((a, b) => b.amount > a.amount ? 1 : -1);
-    if (eligible[0]) return eligible[0];
-    if (options.deadline !== void 0 && Date.now() / 1e3 >= options.deadline) {
-      const error = new Error("HTLC was not filled before the deadline");
-      error.reason = "fill_timeout";
-      throw error;
+  };
+  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);
+      }
     }
-    await sleep(pollMs);
-  }
-}
-async function claimOnchainFill(chain, input) {
-  const now = input.now ?? Math.floor(Date.now() / 1e3);
-  if (input.htlc.refundLocktime - now < ONCHAIN_CLAIM_MARGIN_SECONDS) {
-    const error = new Error(
-      "refund leaf opens too soon to claim safely \u2014 take the covenant refund instead"
-    );
-    error.reason = "claim_window_closed";
-    throw error;
-  }
-  const spend = await buildHtlcClaim(input);
-  const txid = await chain.broadcast(spend.txHex);
-  return { txid, payoutAmount: spend.payoutAmount };
-}
-async function classifyOnchainHtlc(chain, input) {
-  const utxos = await chain.getScriptUtxos(input.htlc.pkScript);
-  const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
-  if (!best) {
-    if (!input.funding) return { phase: "unfunded" };
-    const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
-    if (!spend) return { phase: "unfunded" };
-    const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
-    const txid = btc.Transaction.fromRaw(import_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 };
+  };
+  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");
@@ -1392,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. */
@@ -1419,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 }
@@ -1429,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) => {
@@ -1440,15 +1829,16 @@ 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}`);
   }
 };
 var ARKADE_BTC = "arkade:BTC";
-var ARKADE_ASSET = "arkade:ASSET";
 var LIGHTNING_BTC = "lightning:BTC";
 var ONCHAIN_BTC = "onchain:BTC";
+var arkadeAssetLeg = (id) => `arkade:${id.toString()}`;
+var ARKADE_ASSET = "arkade:ASSET";
 var rfqPair = (from, to) => `${from}->${to}`;
 var LIGHTNING_SEND_PAIR = rfqPair(ARKADE_BTC, LIGHTNING_BTC);
 var LIGHTNING_RECEIVE_PAIR = rfqPair(LIGHTNING_BTC, ARKADE_BTC);
@@ -1475,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",
@@ -1485,27 +1875,38 @@ 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) => {
-  if (Boolean(input.wantAsset) === Boolean(input.offerAsset)) {
-    throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
+  if (!input.wantAsset && !input.offerAsset) {
+    throw new Error(
+      "set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC) \u2014 with neither set both legs are BTC, which is not a swap"
+    );
+  }
+  if (input.wantAsset && input.offerAsset) {
+    throw new Error(
+      "set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC) \u2014 asset->asset is nameable on the wire but no solver quotes it yet"
+    );
   }
+  const pair = rfqPair(
+    input.offerAsset ? arkadeAssetLeg(input.offerAsset) : ARKADE_BTC,
+    input.wantAsset ? arkadeAssetLeg(input.wantAsset) : ARKADE_BTC
+  );
+  assertPairLength(pair);
   return {
     v: 1,
     type: "rfq_request",
     rfq_id: input.rfqId,
-    pair: rfqPair(
-      input.offerAsset ? ARKADE_ASSET : ARKADE_BTC,
-      input.wantAsset ? ARKADE_ASSET : ARKADE_BTC
-    ),
+    pair,
     amount_side: input.amountSide,
     amount: input.amount,
-    profile: {
-      ...input.offerAsset && { offer_asset: import_base8.hex.encode(input.offerAsset.serialize()) },
-      ...input.wantAsset && { want_asset: import_base8.hex.encode(input.wantAsset.serialize()) }
-    }
+    // The pair is the only place the asset ids appear. Repeating them here
+    // would be a key the solver's `.strict()` profile schema does not
+    // declare, and an undeclared key is `unsupported_payload` — a refusal,
+    // not an ignored extra. Empty, not absent: `profile` is required on
+    // every other request shape this wire carries.
+    profile: {}
   };
 };
 var MIN_HEADROOM_SECONDS = 90 * 60;
@@ -1519,6 +1920,14 @@ var assertFinite = (value, reason, label) => {
     throw gateError(reason, `${label} is not a finite number (${String(value)})`);
   }
 };
+var MAX_PAIR_LENGTH = 158;
+var assertPairLength = (pair) => {
+  if (pair.length > MAX_PAIR_LENGTH) {
+    throw new Error(
+      `pair is ${pair.length} characters, over the wire's ${MAX_PAIR_LENGTH}-character limit`
+    );
+  }
+};
 var verifyLockupAddress = (quote, derivedAddress) => {
   const quoted = quote.profile?.lockup_address;
   if (derivedAddress !== quoted) throw new AddressMismatch(derivedAddress, quoted);
@@ -1558,14 +1967,20 @@ var assertFundable = (input) => {
     }
   }
 };
-var expectQuote = (payload, rfqId) => {
+var expectQuote = (payload, rfqId, requestedPair) => {
   const p = payload;
   if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
   if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
     throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
   }
+  if (requestedPair !== void 0 && p.pair !== requestedPair) {
+    throw new Error(
+      `solver quoted ${JSON.stringify(p.pair)}, not the requested ${requestedPair}`
+    );
+  }
   return payload;
 };
+var pairOf = (payload) => typeof payload.pair === "string" ? payload.pair : void 0;
 var httpTransport = (baseUrl, options = {}) => {
   const fetchImpl = options.fetchImpl ?? fetch;
   const readJson = async (response, what) => {
@@ -1585,7 +2000,11 @@ var httpTransport = (baseUrl, options = {}) => {
         headers: { "content-type": "application/json" },
         body: JSON.stringify(payload)
       });
-      return expectQuote(await readJson(response, "quote request"), String(payload.rfq_id));
+      return expectQuote(
+        await readJson(response, "quote request"),
+        String(payload.rfq_id),
+        pairOf(payload)
+      );
     },
     async status(rfqId) {
       const response = await fetchImpl(`${baseUrl}/v1/rfq/${rfqId}`, { method: "GET" });
@@ -1662,7 +2081,8 @@ var relayTransport = (relayUrl, options) => {
     async requestQuote(payload) {
       return expectQuote(
         await roundTrip(payload, String(payload.rfq_id)),
-        String(payload.rfq_id)
+        String(payload.rfq_id),
+        pairOf(payload)
       );
     },
     async status(rfqId) {
@@ -1702,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)),
@@ -1725,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(
@@ -1751,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({
@@ -1786,7 +2207,8 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     script,
     refundAddress,
     senderPubkey,
-    secrets
+    secrets,
+    treeParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -1805,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) => ({
@@ -1820,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
   }
 });
@@ -1834,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) {
@@ -1852,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,
@@ -1860,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
@@ -1886,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(
@@ -1909,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)),
@@ -1948,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
   };
@@ -2024,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)),
@@ -2054,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,
@@ -2063,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({
@@ -2100,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)),
@@ -2139,7 +2565,8 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     script: derived.script,
     payoutAddress,
     payoutPubkey,
-    secrets
+    secrets,
+    treeParams: derived.treeParams
   };
 }
 function deriveOnchainReceive(input) {
@@ -2155,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,
@@ -2163,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
     },
@@ -2189,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({
@@ -2219,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)),
@@ -2265,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"];
@@ -2320,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 })
@@ -2345,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;
     }
@@ -2374,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");
@@ -2403,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,
@@ -2423,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);
@@ -2514,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,
@@ -2574,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);
@@ -2591,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`,
@@ -2611,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":
@@ -2630,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 {
@@ -2707,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();
@@ -2729,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;
   }
@@ -2749,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
@@ -2758,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);
@@ -2791,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;
@@ -2801,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
@@ -2818,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() {
@@ -2880,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
@@ -2889,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);
@@ -2951,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);
@@ -2970,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;
@@ -2995,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;
@@ -3033,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;
     }
@@ -3117,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");
@@ -3170,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;
@@ -3284,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);
@@ -3309,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;
@@ -3320,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.
    *
@@ -3379,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",
@@ -3431,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,
@@ -3443,6 +4183,7 @@ function swapActivityResolver(deps) {
   LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR,
   LockupAmountMismatchError,
+  LockupContractMissing,
   LockupNeedsRecoveryError,
   LockupRegistrationFailed,
   MAX_MIN_CONFIRMATIONS,
@@ -3460,16 +4201,20 @@ 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,
   SWAP_LOCKUP_CONTRACT_TYPE,
   SwapRefusal,
   addAssetSwap,
+  arkadeAssetLeg,
+  arkadeRefunder,
   arkadeSwapRequest,
   assertFundable,
   assertReceivable,
@@ -3485,6 +4230,7 @@ function swapActivityResolver(deps) {
   classifyOnchainHtlc,
   classifySpend,
   createOffer,
+  createRfqSwapRecord,
   decodeOffer,
   deriveLightningReceive,
   deriveOnchainReceive,
@@ -3502,6 +4248,7 @@ function swapActivityResolver(deps) {
   lightningReceiveRequest,
   lightningSendRequest,
   lightningSendVtxoScript,
+  lockupContractParams,
   makeCachedFeedFetch,
   newPreimage,
   newRfqId,
@@ -3510,12 +4257,14 @@ function swapActivityResolver(deps) {
   offerVtxoScript,
   onchainHtlcScript,
   onchainReceiveRequest,
+  onchainSendProfile,
   onchainSendRequest,
   paymentHashOf,
   preimageForSwapRecord,
   pushClaim,
   pushRefundWithoutReceiver,
   readLockupFate,
+  rebuildRfqSwap,
   receiveVtxoScript,
   refundIfUnresolved,
   registerLockupContract,
@@ -3526,9 +4275,15 @@ function swapActivityResolver(deps) {
   requestOnchainSend,
   restoreAssetSwaps,
   retireSettledOfferContracts,
+  rfqClaimSecretOf,
   rfqPair,
+  rfqSecretsProfile,
+  rfqSignerOf,
+  rfqSwapActivityInputs,
+  rfqSwapOriginOf,
   sealClaimPacket,
   senderIdentityForSwapRecord,
+  shouldRetainRfqSwap,
   spendTxidsOf,
   spendUpdate,
   swapActivityResolver,
@@ -3539,6 +4294,7 @@ function swapActivityResolver(deps) {
   unilateralRefundWithoutReceiverDelay,
   updateAssetSwap,
   updateAssetSwapBestEffort,
+  updateRfqSwapRecord,
   validatePlan,
   verifyLockupAddress,
   verifyReceiveInvoice,