@arkade-os/swap 0.0.12 → 0.1.0-rc.1

package/dist/index.cjs

@@ -37,6 +37,7 @@ __export(index_exports, {
   InMemoryAssetSwapRepository: () => InMemoryAssetSwapRepository,
   IndexedDbAssetSwapRepository: () => IndexedDbAssetSwapRepository,
   LIGHTNING_BTC: () => LIGHTNING_BTC,
+  LIGHTNING_RAIL: () => LIGHTNING_RAIL,
   LIGHTNING_RECEIVE_PAIR: () => LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR: () => LIGHTNING_SEND_PAIR,
   LOCKTIME_THRESHOLD: () => LOCKTIME_THRESHOLD,
@@ -47,6 +48,7 @@ __export(index_exports, {
   MAX_MIN_CONFIRMATIONS: () => MAX_MIN_CONFIRMATIONS,
   MIN_CLAIM_WINDOW_SECONDS: () => MIN_CLAIM_WINDOW_SECONDS,
   MIN_HEADROOM_SECONDS: () => MIN_HEADROOM_SECONDS,
+  NoSpendableDepositError: () => NoSpendableDepositError,
   OFFER_PACKET_TYPE: () => OFFER_PACKET_TYPE,
   ONCHAIN_BTC: () => ONCHAIN_BTC,
   ONCHAIN_CLAIM_MARGIN_SECONDS: () => ONCHAIN_CLAIM_MARGIN_SECONDS,
@@ -55,6 +57,9 @@ __export(index_exports, {
   ONCHAIN_RECEIVE_PAIR: () => ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK: () => ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR: () => ONCHAIN_SEND_PAIR,
+  ONCHAIN_SWAP_RAIL: () => ONCHAIN_SWAP_RAIL,
+  OfferCovenantMismatchError: () => OfferCovenantMismatchError,
+  PAYMENT_STATUS: () => PAYMENT_STATUS,
   PreimageNotRecoverableError: () => PreimageNotRecoverableError,
   QUOTE_OPTIONS: () => QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS: () => REFUND_MTP_LAG_SECONDS,
@@ -71,6 +76,8 @@ __export(index_exports, {
   SWAP_LOCKUP_CONTRACT_KIND: () => SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL: () => SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE: () => SWAP_LOCKUP_CONTRACT_TYPE,
+  SWAP_ROUTER_PRIORITY: () => SWAP_ROUTER_PRIORITY,
+  SwapPaymentFailedError: () => SwapPaymentFailedError,
   SwapRefusal: () => SwapRefusal,
   addAssetSwap: () => addAssetSwap,
   arkadeAssetLeg: () => arkadeAssetLeg,
@@ -85,6 +92,7 @@ __export(index_exports, {
   buildHtlcRefund: () => buildHtlcRefund,
   cancelOffer: () => cancelOffer,
   chainSourceFrom: () => chainSourceFrom,
+  claimFeeSats: () => claimFeeSats,
   claimOnchainFill: () => claimOnchainFill,
   claimReceiveLockup: () => claimReceiveLockup,
   classifyDepositSpend: () => classifyDepositSpend,
@@ -92,6 +100,8 @@ __export(index_exports, {
   classifySpend: () => classifySpend,
   createOffer: () => createOffer,
   createRfqSwapRecord: () => createRfqSwapRecord,
+  createSwapClient: () => createSwapClient,
+  createSwapPaymentRouter: () => createSwapPaymentRouter,
   decodeOffer: () => decodeOffer,
   deriveLightningReceive: () => deriveLightningReceive,
   deriveOnchainReceive: () => deriveOnchainReceive,
@@ -106,28 +116,35 @@ __export(index_exports, {
   httpTransport: () => httpTransport,
   isRfqSwapTerminal: () => isRfqSwapTerminal,
   isRfqTerminal: () => isRfqTerminal,
+  isTerminalStatus: () => isTerminalStatus,
   l1ScriptForAddress: () => l1ScriptForAddress,
+  lightningRail: () => lightningRail,
+  lightningReceiveContract: () => lightningReceiveContract,
   lightningReceiveRequest: () => lightningReceiveRequest,
+  lightningSendContract: () => lightningSendContract,
   lightningSendRequest: () => lightningSendRequest,
-  lightningSendVtxoScript: () => lightningSendVtxoScript,
   lockupContractParams: () => lockupContractParams,
   makeCachedFeedFetch: () => makeCachedFeedFetch,
   newPreimage: () => newPreimage,
   newRfqId: () => newRfqId,
   nextOnchainAction: () => nextOnchainAction,
+  normalizeRfqSwapRecord: () => normalizeRfqSwapRecord,
+  offerContract: () => offerContract,
   offerTermsFromQuote: () => offerTermsFromQuote,
-  offerVtxoScript: () => offerVtxoScript,
   onchainHtlcScript: () => onchainHtlcScript,
   onchainReceiveRequest: () => onchainReceiveRequest,
   onchainSendProfile: () => onchainSendProfile,
   onchainSendRequest: () => onchainSendRequest,
+  onchainSwapRail: () => onchainSwapRail,
   paymentHashOf: () => paymentHashOf,
+  paymentStatusOf: () => paymentStatusOf,
   preimageForSwapRecord: () => preimageForSwapRecord,
   pushClaim: () => pushClaim,
   pushRefundWithoutReceiver: () => pushRefundWithoutReceiver,
+  railAvailable: () => railAvailable,
   readLockupFate: () => readLockupFate,
   rebuildRfqSwap: () => rebuildRfqSwap,
-  receiveVtxoScript: () => receiveVtxoScript,
+  receiverExact: () => receiverExact,
   refundIfUnresolved: () => refundIfUnresolved,
   registerLockupContract: () => registerLockupContract,
   relayTransport: () => relayTransport,
@@ -154,6 +171,7 @@ __export(index_exports, {
   spendTxidsOf: () => spendTxidsOf,
   spendUpdate: () => spendUpdate,
   swapActivityResolver: () => swapActivityResolver,
+  swapHandle: () => swapHandle,
   swapPrograms: () => swapPrograms,
   swapSecretsToRecord: () => swapSecretsToRecord,
   unilateralClaimDelay: () => unilateralClaimDelay,
@@ -333,9 +351,9 @@ var addAssetSwap = async (repository, swap) => {
   const swaps = await getAssetSwapsOrThrow(repository);
   if (swaps.some((s) => s.id === swap.id)) return swaps;
   await saveSwapOrThrow(repository, swap);
-  const at = swaps.findIndex((s) => byNewest(swap, s) <= 0);
+  const at2 = swaps.findIndex((s) => byNewest(swap, s) <= 0);
   const merged = [...swaps];
-  merged.splice(at === -1 ? merged.length : at, 0, swap);
+  merged.splice(at2 === -1 ? merged.length : at2, 0, swap);
   return merged;
 };
 var updateAssetSwap = async (repository, id, changes) => {
@@ -435,7 +453,7 @@ function withExitClosure(program, exit) {
     }
   };
 }
-function swapProgramBinding(offer, serverPubkey) {
+function swapProgramBinding(offer, operatorPubkey) {
   if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
     throw new Error("makerPkScript is not a 34-byte taproot scriptPubKey");
   }
@@ -447,7 +465,7 @@ function swapProgramBinding(offer, serverPubkey) {
     args: {
       makerWP: offer.makerPkScript.subarray(2),
       wantAmount: offer.wantAmount,
-      server: serverPubkey,
+      server: operatorPubkey,
       user: offer.makerPublicKey,
       // internal byte order
       ...offer.wantAsset && {
@@ -457,14 +475,14 @@ function swapProgramBinding(offer, serverPubkey) {
       ...offer.exitDelay && { exitDelay: offer.exitDelay.value }
     },
     keys: {
-      serverKey: serverPubkey,
+      serverKey: operatorPubkey,
       userKey: offer.makerPublicKey,
       emulatorKey: offer.emulatorPubkey
     }
   };
 }
-function offerVtxoScript(offer, serverPubkey) {
-  const { program, args, keys } = swapProgramBinding(offer, serverPubkey);
+function offerContract(offer, operatorPubkey) {
+  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
   return new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
 }
 var OFFER_PACKET_TYPE = 3;
@@ -578,14 +596,14 @@ function decodeOffer(data) {
       throw new Error(`missing/invalid ${name}`);
     }
   }
-  const need = (name) => {
+  const need2 = (name) => {
     const v = fields[name];
     const len = FIELDS[name].width;
     if (!v || len !== void 0 && v.length !== len)
       throw new Error(`missing/invalid ${name}`);
     return v;
   };
-  const amount = need("wantAmount");
+  const amount = need2("wantAmount");
   if (Boolean(fields.wantAsset) === Boolean(fields.offerAsset)) {
     throw new Error("offer must carry exactly one of wantAsset or offerAsset");
   }
@@ -602,13 +620,13 @@ function decodeOffer(data) {
     throw new Error("offer must carry both ratioNum and ratioDen, or neither");
   }
   return {
-    swapPkScript: need("swapPkScript"),
+    swapPkScript: need2("swapPkScript"),
     wantAmount: readU64(amount),
     ...fields.wantAsset && { wantAsset: import_sdk2.asset.AssetId.fromBytes(fields.wantAsset) },
     ...fields.offerAsset && { offerAsset: import_sdk2.asset.AssetId.fromBytes(fields.offerAsset) },
-    makerPkScript: need("makerPkScript"),
-    makerPublicKey: need("makerPublicKey"),
-    emulatorPubkey: need("emulatorPubkey"),
+    makerPkScript: need2("makerPkScript"),
+    makerPublicKey: need2("makerPublicKey"),
+    emulatorPubkey: need2("emulatorPubkey"),
     ...ratioNum !== void 0 && { ratioNum },
     ...ratioDen !== void 0 && { ratioDen },
     ...fields.exitTimelock && { exitDelay: decodeExitDelay(fields.exitTimelock) }
@@ -621,17 +639,21 @@ function decodeExitDelay(value) {
 }
 var OFFER_CONTRACT_LABEL = "Arkade swap offer";
 var OFFER_CONTRACT_KIND = "asset-swap-offer";
-async function registerOfferContract(wallet, arkServerUrl, network, binding, serverPubkey, expectedPkScript) {
-  const { program, args, keys } = swapProgramBinding(binding, serverPubkey);
+async function registerOfferContract(wallet, info, binding, operatorPubkey, expectedPkScript) {
+  const { program, args, keys } = swapProgramBinding(binding, operatorPubkey);
   const contractManager = await wallet.getContractManager();
   const client = await import_sdk2.arkade.Arkade.connect({
-    arkade: new import_sdk2.RestArkProvider(arkServerUrl),
-    indexer: new import_sdk2.RestIndexerProvider(arkServerUrl),
+    // Registration derives and persists; it never broadcasts and never
+    // reads UTXOs, so the only thing the client needs off the server is the
+    // info the caller already resolved. Handing that back — rather than a
+    // provider built from a URL — is what lets `createOffer` take just a
+    // wallet, and spares a second `/v1/info` round-trip.
+    arkade: { getInfo: async () => info },
     identity: wallet.identity,
     // without this the row's `address` would be derived against the SDK's
     // default network while its script is right — a row that disagrees with
     // the address the user is about to fund
-    network: (0, import_sdk2.getNetwork)(network),
+    network: (0, import_sdk2.networkFromArkadeInfo)(info),
     contractManager
   });
   const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
@@ -652,17 +674,21 @@ function serverExitDelay(delay) {
   }
   return assertExitDelay({ value: delay, type: delay < BigInt(512) ? "blocks" : "seconds" });
 }
-async function createOffer(wallet, arkServerUrl, params) {
+async function createOffer(wallet, params) {
   if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
     throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
   }
   const [info, makerAddress, makerPublicKey] = await Promise.all([
-    new import_sdk2.RestArkProvider(arkServerUrl).getInfo(),
+    // requireLive: this info binds signerPubkey into the covenant — a
+    // snapshot could derive an address the operator no longer co-signs
+    // for, so an unreachable operator fails the call instead (fail closed,
+    // the same behaviour the pre-#734 caller-held provider had)
+    wallet.getArkadeInfo({ requireLive: true }),
     wallet.getAddress(),
     wallet.identity.xOnlyPublicKey()
   ]);
-  const serverPubKey = import_base2.hex.decode((0, import_sdk2.toXOnlySignerHex)(info.signerPubkey));
-  const network = (0, import_sdk2.getNetwork)(info.network);
+  const operatorPubKey = import_base2.hex.decode((0, import_sdk2.toXOnlySignerHex)(info.signerPubkey));
+  const network = (0, import_sdk2.networkFromArkadeInfo)(info);
   const emuKey = import_base2.hex.decode(
     (0, import_sdk2.toXOnlySignerHex)((0, import_sdk2.resolveEmulatorPubkey)(network, params.emulatorPubkey))
   );
@@ -678,33 +704,77 @@ async function createOffer(wallet, arkServerUrl, params) {
     // an offer that then fails to encode. @see assertExitDelay
     exitDelay: params.noExit ? void 0 : params.exitDelay ? assertExitDelay(params.exitDelay) : serverExitDelay(info.unilateralExitDelay)
   };
-  const script = offerVtxoScript(binding, serverPubKey);
+  const script = offerContract(binding, operatorPubKey);
   const offer = { ...binding, swapPkScript: script.pkScript };
-  await registerOfferContract(
-    wallet,
-    arkServerUrl,
-    info.network,
-    binding,
-    serverPubKey,
-    script.pkScript
-  );
+  await registerOfferContract(wallet, info, binding, operatorPubKey, script.pkScript);
   const payload = encodeOffer(offer);
   return {
     offerHex: import_base2.hex.encode(payload),
     extension: { type: OFFER_PACKET_TYPE, payload },
-    // VtxoScript.address owns address construction; assembling an ArkAddress
+    // the contract's .address() builds the address; assembling an ArkAddress
     // from tweakedPublicKey here would silently miss any future step it gains
-    address: script.address(network.hrp, serverPubKey).encode(),
+    address: script.address(network.hrp, operatorPubKey).encode(),
     swapPkScript: script.pkScript
   };
 }
-async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
+async function cancelOffer(wallet, offerHex, opts) {
   const { repository, fundingTxid, swapAddress } = opts;
+  const prepared = await prepareOfferCancel(wallet, offerHex, {
+    ...fundingTxid === void 0 ? {} : { fundingTxid },
+    ...swapAddress === void 0 ? {} : { swapAddress }
+  });
+  const swapId = fundingTxid ?? prepared.vtxo.txid;
+  const hasLocalRecord = (await getAssetSwapsOrThrow(repository)).some((s) => s.id === swapId);
+  if (hasLocalRecord) await updateAssetSwap(repository, swapId, { status: "cancelling" });
+  const txid = await prepared.send();
+  if (hasLocalRecord) {
+    const { persisted, swaps } = await updateAssetSwapBestEffort(repository, swapId, {
+      status: "cancelled",
+      spentTxid: txid
+    });
+    if (persisted) {
+      const contractManager = await wallet.getContractManager();
+      await retireOfferContract(
+        contractManager,
+        swaps,
+        import_base2.hex.encode(prepared.offer.swapPkScript)
+      );
+    }
+  }
+  return txid;
+}
+var OFFER_COVENANT_MISMATCH = "rebuilt covenant does not match the offer's swapPkScript";
+var NoSpendableDepositError = class extends Error {
+  name = "NoSpendableDepositError";
+  constructor(options) {
+    super("no spendable VTXO at the swap address", options);
+  }
+};
+var OfferCovenantMismatchError = class extends Error {
+  constructor(swapPkScript, options) {
+    super(
+      `${OFFER_COVENANT_MISMATCH} \u2014 the operator signing key pinned by the rebuild does not reproduce the funded covenant; the signing key has likely rotated since funding (pass swapAddress, the funded address, to pin the original key), or the record is corrupt`,
+      options
+    );
+    this.swapPkScript = swapPkScript;
+  }
+  swapPkScript;
+  name = "OfferCovenantMismatchError";
+};
+async function prepareOfferCancel(wallet, offerHex, opts) {
+  const { fundingTxid, swapAddress } = opts;
   const offer = decodeOffer(import_base2.hex.decode(offerHex));
-  const contractManager = await wallet.getContractManager();
+  const [contractManager, info, reader, broadcaster] = await Promise.all([
+    wallet.getContractManager(),
+    wallet.getArkadeInfo({ requireLive: true }),
+    wallet.getArkadeReader(),
+    wallet.getArkadeBroadcaster()
+  ]);
   const client = await import_sdk2.arkade.Arkade.connect({
-    arkade: new import_sdk2.RestArkProvider(arkServerUrl),
-    indexer: new import_sdk2.RestIndexerProvider(arkServerUrl),
+    // info the wallet already holds, plus its broadcast pair — the shape
+    // `ArkadeServerProvider` describes, without a second `/v1/info`
+    arkade: { getInfo: async () => info, ...broadcaster },
+    indexer: reader,
     identity: wallet.identity,
     // registered offers resolve their VTXOs from the contract repository
     // instead of a direct indexer query; the indexer above stays as the
@@ -718,9 +788,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
   const rebuilt = new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
   if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.hex.encode(offer.swapPkScript)) {
-    throw new Error(
-      "rebuilt covenant does not match the offer's swapPkScript \u2014 the server signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
-    );
+    throw new OfferCovenantMismatchError(import_base2.hex.encode(offer.swapPkScript));
   }
   const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
   const [vtxos, makerAddress] = await Promise.all([contract.getUtxos(), wallet.getAddress()]);
@@ -730,7 +798,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
     );
   }
   const vtxo = fundingTxid ? vtxos.find((v) => v.txid === fundingTxid) : vtxos[0];
-  if (!vtxo) throw new Error("no spendable VTXO at the swap address");
+  if (!vtxo) throw new NoSpendableDepositError();
   const makerPkScript = import_sdk2.ArkAddress.decode(makerAddress).pkScript;
   const cancel = contract.functions.cancel().from({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value }).to(makerPkScript, BigInt(vtxo.value));
   for (const a of vtxo.assets ?? []) {
@@ -740,20 +808,11 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
       outputs: [{ vout: 0, amount: BigInt(a.amount) }]
     });
   }
-  const swapId = fundingTxid ?? vtxo.txid;
-  const hasLocalRecord = (await getAssetSwapsOrThrow(repository)).some((s) => s.id === swapId);
-  if (hasLocalRecord) await updateAssetSwap(repository, swapId, { status: "cancelling" });
-  const { txid } = await cancel.send();
-  if (hasLocalRecord) {
-    const { persisted, swaps } = await updateAssetSwapBestEffort(repository, swapId, {
-      status: "cancelled",
-      spentTxid: txid
-    });
-    if (persisted) {
-      await retireOfferContract(contractManager, swaps, import_base2.hex.encode(offer.swapPkScript));
-    }
-  }
-  return txid;
+  return {
+    offer,
+    vtxo: { txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value },
+    send: async () => (await cancel.send()).txid
+  };
 }
 
 // src/markets.ts
@@ -883,8 +942,9 @@ var validatePlan = (plan, giveBalance, dust) => {
 // src/repository.ts
 var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
 var InMemoryAssetSwapRepository = class {
-  version = 4;
+  version = 5;
   swaps = /* @__PURE__ */ new Map();
+  records = /* @__PURE__ */ new Map();
   rfqSwaps = /* @__PURE__ */ new Map();
   scanned = /* @__PURE__ */ new Set();
   markets = /* @__PURE__ */ new Map();
@@ -906,6 +966,18 @@ var InMemoryAssetSwapRepository = class {
   async removeRfqSwap(rfqId) {
     this.rfqSwaps.delete(rfqId);
   }
+  async saveSwapRecord(record) {
+    this.records.set(record.id, record);
+  }
+  async getSwapRecord(id) {
+    return this.records.get(id);
+  }
+  async getAllSwapRecords() {
+    return [...this.records.values()];
+  }
+  async removeSwapRecord(id) {
+    this.records.delete(id);
+  }
   async getScannedTxids() {
     return new Set(this.scanned);
   }
@@ -921,6 +993,7 @@ var InMemoryAssetSwapRepository = class {
   async clear() {
     this.swaps.clear();
     this.rfqSwaps.clear();
+    this.records.clear();
     this.scanned.clear();
     this.markets.clear();
   }
@@ -931,9 +1004,10 @@ var InMemoryAssetSwapRepository = class {
 // src/indexedDbRepository.ts
 var import_sdk4 = require("@arkade-os/sdk");
 var DEFAULT_DB_NAME = "arkade-intents";
-var DB_VERSION = 2;
+var DB_VERSION = 3;
 var STORE_SWAPS = "swaps";
 var STORE_RFQ_SWAPS = "rfqSwaps";
+var STORE_SWAP_RECORDS = "swapRecords";
 var STORE_SCANNED = "scannedTxids";
 var STORE_MARKETS = "markets";
 var STORES = [
@@ -941,6 +1015,11 @@ var STORES = [
   // 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" }],
+  // v3. The v2 client's accept records, keyed by quote id. Its own store for
+  // the same reason, plus one more: the v1 read path drops a row carrying
+  // neither `offerHex` nor `paymentHash`, so sharing `swaps` would pin the
+  // v2 shape to a v1 predicate.
+  [STORE_SWAP_RECORDS, { keyPath: "id" }],
   [STORE_SCANNED],
   [STORE_MARKETS]
 ];
@@ -952,7 +1031,7 @@ function initDatabase(db, oldVersion, transaction) {
   }
 }
 var IndexedDbAssetSwapRepository = class {
-  version = 4;
+  version = 5;
   connection;
   constructor(dbName = DEFAULT_DB_NAME) {
     this.connection = (0, import_sdk4.createManagedConnection)(dbName, DB_VERSION, initDatabase);
@@ -996,6 +1075,22 @@ var IndexedDbAssetSwapRepository = class {
       store.delete(rfqId);
     });
   }
+  async saveSwapRecord(record) {
+    await this.write(STORE_SWAP_RECORDS, (store) => {
+      store.put(record);
+    });
+  }
+  async getSwapRecord(id) {
+    return (0, import_sdk4.promisifyRequest)((await this.readStore(STORE_SWAP_RECORDS)).get(id));
+  }
+  async getAllSwapRecords() {
+    return (0, import_sdk4.promisifyRequest)((await this.readStore(STORE_SWAP_RECORDS)).getAll());
+  }
+  async removeSwapRecord(id) {
+    await this.write(STORE_SWAP_RECORDS, (store) => {
+      store.delete(id);
+    });
+  }
   async getScannedTxids() {
     const keys = await (0, import_sdk4.promisifyRequest)((await this.readStore(STORE_SCANNED)).getAllKeys());
     return new Set(keys);
@@ -1102,6 +1197,14 @@ var parseSigner = (value) => {
   }
   return { signingDescriptor };
 };
+var parsePayoutAddress = (value, kind) => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(
+      `this ${kind} record's claim destination is unusable: expected an Arkade address, got ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+};
 var parseHashlock = (value) => {
   const raw = value ?? {};
   const hashlock = {
@@ -1147,6 +1250,11 @@ var rfqClaimSecretOf = (record) => {
     );
   }
 };
+var rfqClaimDestinationOf = (record) => {
+  const handler = rfqCorridorHandlers.getOrThrow(record.kind);
+  if (!handler.claimDestination) return void 0;
+  return parsePayoutAddress(handler.claimDestination(record.profile), record.kind);
+};
 
 // src/onchainHtlc.ts
 var import_base3 = require("@scure/base");
@@ -1159,6 +1267,7 @@ var MAX_MIN_CONFIRMATIONS = 6;
 var LOCKTIME_THRESHOLD = 5e8;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
+var ONCHAIN_CLAIM_VSIZE = 152;
 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));
@@ -1388,7 +1497,7 @@ var LightningReceiveCorridor = {
     const receive = swap;
     return {
       expectedAmount: receive.expectedAmount,
-      ...receive.claimArkTxid ? { claimArkTxid: receive.claimArkTxid } : {}
+      ...receive.claimTxid ? { claimTxid: receive.claimTxid } : {}
     };
   },
   hydrate(profile) {
@@ -1398,13 +1507,16 @@ var LightningReceiveCorridor = {
     return {
       ...hydrateHashlock(profile),
       expectedAmount: profile.expectedAmount,
-      ...profile.claimArkTxid ? { claimArkTxid: profile.claimArkTxid } : {}
+      ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {}
     };
   },
   // 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] : []
+  // The other half of claiming: where it pays. Written once at request time
+  // and left alone by `project` above, so this hands back what was stored.
+  claimDestination: (profile) => profile.payoutAddress,
+  activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
 };
 function onchainSendProfile(result) {
   return {
@@ -1492,14 +1604,34 @@ var isRfqSwapTerminal = (state) => RFQ_SWAP_TERMINAL_STATES.includes(state);
 
 // src/rfqRecord.ts
 var RFQ_SWAP_RETENTION_SECONDS = 30 * 24 * 60 * 60;
+function renameLegacyClaimTxid(profile) {
+  const { claimArkTxid, ...rest } = profile;
+  return { ...rest, claimTxid: rest.claimTxid ?? claimArkTxid };
+}
+function normalizeRfqSwapRecord(record) {
+  const { fundingArkTxid, refundArkTxid, lockupSpendArkTxids, ...rest } = record;
+  const legacyClaim = record.kind === "lightning_receive" && record.profile.claimArkTxid !== void 0;
+  if (!fundingArkTxid && !refundArkTxid && !lockupSpendArkTxids && !legacyClaim) return record;
+  const fundingTxid = rest.fundingTxid ?? fundingArkTxid;
+  const refundTxid = rest.refundTxid ?? refundArkTxid;
+  const lockupSpendTxids = rest.lockupSpendTxids ?? lockupSpendArkTxids;
+  return {
+    ...rest,
+    ...fundingTxid ? { fundingTxid } : {},
+    ...refundTxid ? { refundTxid } : {},
+    ...lockupSpendTxids?.length ? { lockupSpendTxids } : {},
+    ...legacyClaim ? { profile: renameLegacyClaimTxid(record.profile) } : {}
+  };
+}
 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.refundTxid ? { refundTxid: swap.refundTxid } : {},
+  ...swap.lockupSpendTxids?.length ? { lockupSpendTxids: [...swap.lockupSpendTxids] } : {},
   ...swap.failure ? { failure: swap.failure } : {},
+  ...swap.claimFailure ? { claimFailure: swap.claimFailure } : {},
   ...swap.blockedReason ? { blockedReason: swap.blockedReason } : {}
 });
 function assertSameSwap(origin, swap) {
@@ -1529,27 +1661,30 @@ function createRfqSwapRecord(origin, swap) {
 }
 function updateRfqSwapRecord(record, swap) {
   assertSameSwap(record, swap);
+  const stored = normalizeRfqSwapRecord(record);
   const {
-    refundArkTxid: _refundArkTxid,
-    lockupSpendArkTxids: _lockupSpendArkTxids,
+    refundTxid: _refundTxid,
+    lockupSpendTxids: _lockupSpendTxids,
     failure: _failure,
+    claimFailure: _claimFailure,
     blockedReason: _blockedReason,
     ...origin
-  } = record;
-  const handler = rfqCorridorHandlers.getOrThrow(record.kind);
+  } = stored;
+  const handler = rfqCorridorHandlers.getOrThrow(stored.kind);
   return {
     ...origin,
     ...managerState(swap),
-    profile: { ...record.profile, ...handler.project(swap) }
+    profile: { ...stored.profile, ...handler.project(swap) }
   };
 }
 function rfqSwapOriginOf(record) {
+  const stored = normalizeRfqSwapRecord(record);
   return {
-    kind: record.kind,
-    lockupAddress: record.lockupAddress,
-    profile: { ...record.profile },
-    ...record.amount !== void 0 ? { amount: record.amount } : {},
-    ...record.fundingArkTxid ? { fundingArkTxid: record.fundingArkTxid } : {}
+    kind: stored.kind,
+    lockupAddress: stored.lockupAddress,
+    profile: { ...stored.profile },
+    ...stored.amount !== void 0 ? { amount: stored.amount } : {},
+    ...stored.fundingTxid ? { fundingTxid: stored.fundingTxid } : {}
   };
 }
 function lockupScript(params, lockupAddress) {
@@ -1563,27 +1698,29 @@ function lockupScript(params, lockupAddress) {
   return script;
 }
 function rebuildRfqSwap(record, params) {
-  const script = lockupScript(params, record.lockupAddress);
+  const stored = normalizeRfqSwapRecord(record);
+  const script = lockupScript(params, stored.lockupAddress);
   const common = {
-    rfqId: record.rfqId,
-    state: record.state,
+    rfqId: stored.rfqId,
+    state: stored.state,
     lockupPkScript: script.pkScript,
-    lockup: { script, address: record.lockupAddress },
+    lockup: { script, address: stored.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 } : {}
+    createdAt: stored.createdAt,
+    updatedAt: stored.updatedAt,
+    ...stored.refundTxid ? { refundTxid: stored.refundTxid } : {},
+    ...stored.lockupSpendTxids?.length ? { lockupSpendTxids: [...stored.lockupSpendTxids] } : {},
+    ...stored.failure ? { failure: stored.failure } : {},
+    ...stored.claimFailure ? { claimFailure: stored.claimFailure } : {},
+    ...stored.blockedReason ? { blockedReason: stored.blockedReason } : {}
   };
-  const handler = rfqCorridorHandlers.getOrThrow(record.kind);
+  const handler = rfqCorridorHandlers.getOrThrow(stored.kind);
   return {
     ...common,
-    kind: record.kind,
-    ...handler.hydrate(record.profile, { lockup: script })
+    kind: stored.kind,
+    ...handler.hydrate(stored.profile, { lockup: script })
   };
 }
 function shouldRetainRfqSwap(record, now) {
@@ -1620,10 +1757,10 @@ async function fetchParsedTxs(indexer, txids) {
 var unscannedSwapCandidates = (txs, existingIds, scanned) => txs.filter(
   (tx) => tx.type === "sent" && tx.redeemTxid && !existingIds.has(tx.redeemTxid) && !scanned.has(tx.redeemTxid)
 );
-function classifySpend(offer, serverPubkey, spendTx, deposit) {
+function classifySpend(offer, operatorPubkey, spendTx, deposit) {
   let leaves;
   try {
-    const script = offerVtxoScript(offer, serverPubkey);
+    const script = offerContract(offer, operatorPubkey);
     if (import_base6.hex.encode(script.pkScript) !== import_base6.hex.encode(offer.swapPkScript)) return "indeterminate";
     leaves = {
       // both routes that hand the deposit back; `exit` is absent on an
@@ -1647,15 +1784,15 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
   return "indeterminate";
 }
 var spendTxidsOf = (vtxo) => [vtxo.spentBy, vtxo.arkTxId].filter((id) => Boolean(id));
-function classifyDepositSpend(offer, serverPubkey, spendTxs, deposit) {
+function classifyDepositSpend(offer, operatorPubkey, spendTxs, deposit) {
   for (const tx of spendTxs) {
-    const kind = classifySpend(offer, serverPubkey, tx, deposit);
+    const kind = classifySpend(offer, operatorPubkey, tx, deposit);
     if (kind !== "indeterminate") return kind;
   }
   return "indeterminate";
 }
 async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
-  const { serverPubkey, scanned = /* @__PURE__ */ new Set() } = opts;
+  const { operatorPubkey, scanned = /* @__PURE__ */ new Set() } = opts;
   const candidates = unscannedSwapCandidates(txs, existingIds, scanned);
   if (candidates.length === 0) return { restored: [], scannedTxids: [] };
   const byTxid = new Map(candidates.map((tx) => [tx.redeemTxid, tx]));
@@ -1724,7 +1861,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
     if (state === "swept") status = "recoverable";
     else if (state === "spent") {
       const spendTxs = spendTxidsOf(vtxo).map((id) => spendTxByTxid.get(id)).filter((tx) => tx !== void 0);
-      const kind = classifyDepositSpend(offer, serverPubkey, spendTxs, {
+      const kind = classifyDepositSpend(offer, operatorPubkey, spendTxs, {
         txid: vtxo.txid,
         vout: vtxo.vout
       });
@@ -1741,7 +1878,7 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
       fromAmount,
       toAmount: offer.wantAmount.toString(),
       // ponytail(arkade-os/ts-sdk#680): empty address makes cancel fall back
-      // to the current server key; store the funded address if server-key
+      // to the current operator key; store the funded address if operator-key
       // rotations become real (cancelOffer now at least diagnoses the
       // mismatch instead of reporting a missing VTXO)
       swapAddress: "",
@@ -1763,6 +1900,10 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 var import_base7 = require("@scure/base");
 var import_sdk7 = require("@arkade-os/sdk");
 var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
+var assetSwapSource = (repository) => ({
+  list: () => getAssetSwaps(repository),
+  apply: async (swap, changes) => updateAssetSwapBestEffort(repository, swap.id, changes)
+});
 function spendUpdate(swap, spend) {
   if (TERMINAL.includes(swap.status)) return void 0;
   if (spend.kind === "indeterminate") return void 0;
@@ -1776,13 +1917,20 @@ function spendUpdate(swap, spend) {
 }
 async function watchOfferSwaps({
   wallet,
-  arkServerUrl,
   repository,
+  source,
   onUpdate
 }) {
-  const manager = await wallet.getContractManager();
-  const serverPubkey = import_sdk7.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
-  const indexer = new import_sdk7.RestIndexerProvider(arkServerUrl);
+  if (!source && !repository) {
+    throw new Error("watchOfferSwaps needs either a record source or a repository");
+  }
+  const records = source ?? assetSwapSource(repository);
+  const [manager, address, indexer] = await Promise.all([
+    wallet.getContractManager(),
+    wallet.getAddress(),
+    wallet.getArkadeReader()
+  ]);
+  const operatorPubkey = import_sdk7.ArkAddress.decode(address).serverPubKey;
   let queue = Promise.resolve();
   const enqueue = (task) => {
     queue = queue.then(task).catch(() => {
@@ -1796,7 +1944,7 @@ async function watchOfferSwaps({
       const { txs } = await indexer.getVirtualTxs(candidates);
       return classifyDepositSpend(
         decodeOffer(import_base7.hex.decode(swap.offerHex)),
-        serverPubkey,
+        operatorPubkey,
         txs.map((psbt) => import_sdk7.Transaction.fromPSBT(import_base7.base64.decode(psbt))),
         { txid: vtxo.txid, vout: vtxo.vout }
       );
@@ -1809,20 +1957,16 @@ async function watchOfferSwaps({
     for (const vtxo of event.vtxos) {
       const spentTxid = vtxo.arkTxId || vtxo.spentBy;
       if (!spentTxid) continue;
-      const swap = (await getAssetSwaps(repository)).find(
+      const swap = (await records.list()).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
-      );
+      const { persisted, swaps } = await records.apply(swap, changes);
       if (!persisted) continue;
-      onUpdate?.({ ...swap, ...changes });
+      onUpdate?.(swaps.find((s) => s.id === swap.id) ?? swap);
       if (changes.status && RETIRABLE.includes(changes.status)) {
         await retireOfferContract(manager, swaps, event.contractScript);
       }
@@ -1950,11 +2094,14 @@ var ONCHAIN_SEND_PAIR = rfqPair(ARKADE_BTC, ONCHAIN_BTC);
 var ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
 var RFQ_TERMINAL_STATES = ["settled", "refused", "expired", "refunded", "stuck"];
 var SwapRefusal = class extends Error {
+  /** Literal-typed so the v2 error taxonomy's union discriminates on `name`
+   * — a `string` here collapses the discriminant for every member. Same value
+   * the constructor has always set, moved to a field initializer. */
+  name = "SwapRefusal";
   reason;
   rfqId;
   constructor(reason, rfqId) {
     super(`solver refused: ${reason}`);
-    this.name = "SwapRefusal";
     this.reason = reason;
     this.rfqId = rfqId;
   }
@@ -2055,6 +2202,10 @@ var assertFundable = (input) => {
   const fail = (reason, message) => {
     throw gateError(reason, message);
   };
+  if (input.quote.valid_until === void 0) {
+    fail("quote_malformed", "quote carries no valid_until");
+  }
+  assertFinite(input.quote.valid_until, "quote_malformed", "quote valid_until");
   if (input.invoiceExpiresAt !== void 0 && input.now >= input.invoiceExpiresAt) {
     fail("invoice_expired", "invoice expired");
   }
@@ -2257,22 +2408,22 @@ var relayTransport = (relayUrl, options) => {
 };
 var SEQUENCE_GRANULARITY_SECONDS = 512;
 var SOLO_REFUND_HEADROOM_SECONDS = 8 * SEQUENCE_GRANULARITY_SECONDS;
-var unilateralClaimDelay = (serverExitDelaySeconds) => {
-  if (!Number.isFinite(serverExitDelaySeconds) || serverExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
+var unilateralClaimDelay = (operatorExitDelaySeconds) => {
+  if (!Number.isFinite(operatorExitDelaySeconds) || operatorExitDelaySeconds < SEQUENCE_GRANULARITY_SECONDS) {
     throw new Error(
-      `server exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${serverExitDelaySeconds}`
+      `operator exit delay must be at least ${SEQUENCE_GRANULARITY_SECONDS}s of seconds, got ${operatorExitDelaySeconds}`
     );
   }
-  if (serverExitDelaySeconds > 65535 * SEQUENCE_GRANULARITY_SECONDS - SOLO_REFUND_HEADROOM_SECONDS) {
+  if (operatorExitDelaySeconds > 65535 * SEQUENCE_GRANULARITY_SECONDS - SOLO_REFUND_HEADROOM_SECONDS) {
     throw new Error(
-      `server exit delay ${serverExitDelaySeconds}s exceeds what BIP68 can encode once the solo refund's headroom is stacked above it`
+      `operator exit delay ${operatorExitDelaySeconds}s exceeds what BIP68 can encode once the solo refund's headroom is stacked above it`
     );
   }
-  return Math.ceil(serverExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
+  return Math.ceil(operatorExitDelaySeconds / SEQUENCE_GRANULARITY_SECONDS) * SEQUENCE_GRANULARITY_SECONDS;
 };
 var unilateralRefundDelay = (claimDelay) => claimDelay;
 var unilateralRefundWithoutReceiverDelay = (claimDelay) => claimDelay + SOLO_REFUND_HEADROOM_SECONDS;
-function lightningSendVtxoScript(params) {
+function lightningSendContract(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
@@ -2280,7 +2431,7 @@ function lightningSendVtxoScript(params) {
   return new import_sdk9.VHTLC.ScriptV2({
     sender: params.senderPubkey,
     receiver: params.solverPubkey,
-    server: params.serverPubkey,
+    server: params.operatorPubkey,
     preimageHash: (0, import_legacy2.ripemd160)(import_base10.hex.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
@@ -2296,15 +2447,8 @@ function lightningSendVtxoScript(params) {
     }
   });
 }
-async function requestLightningSend(wallet, arkServerUrl, transport, params) {
-  const rfqId = params.rfqId ?? newRfqId();
-  const secrets = await (0, import_sdk10.provisionRefundKey)(wallet);
-  const senderPubkey = secrets.pubkey;
-  const refundAddress = secrets.address;
-  const info = await new import_sdk9.RestArkProvider(arkServerUrl).getInfo();
-  const quote = await transport.requestQuote(
-    lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
-  );
+function deriveLightningSend(input) {
+  const { quote } = input;
   if (quote.refund_locktime === void 0) {
     throw new Error("lightning-send quote is missing refund_locktime");
   }
@@ -2312,6 +2456,43 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   if (receiverPkScriptHex === void 0) {
     throw new Error("lightning-send quote is missing profile.receiver_pk_script");
   }
+  const contractParams = {
+    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    refundLocktime: quote.refund_locktime,
+    operatorPubkey: input.operatorPubkey,
+    paymentHash: input.paymentHash,
+    claimDelay: input.claimDelay,
+    emulatorPubkey: input.emulatorPubkey,
+    senderPubkey: input.senderPubkey,
+    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
+    refundPkScript: input.refundPkScript
+  };
+  const matched = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
+  return {
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    contractParams: {
+      ...contractParams,
+      ...matched.legacy !== void 0 && { legacy: matched.legacy }
+    },
+    refundLocktime: quote.refund_locktime
+  };
+}
+async function requestLightningSend(wallet, transport, params) {
+  const rfqId = params.rfqId ?? newRfqId();
+  const secrets = await (0, import_sdk10.provisionRefundKey)(wallet);
+  const senderPubkey = secrets.pubkey;
+  const refundAddress = secrets.address;
+  const info = await wallet.getArkadeInfo({ requireLive: true });
+  const quote = await transport.requestQuote(
+    lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
+  );
   if (quote.to_amount !== params.invoice.amountSats) {
     throw new Error(
       `quote to_amount ${quote.to_amount} does not match the invoice's ${params.invoice.amountSats}`
@@ -2322,34 +2503,22 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key");
-  const network = (0, import_sdk9.getNetwork)(info.network);
-  const treeParams = {
-    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
-    refundLocktime: quote.refund_locktime,
-    serverPubkey,
+  const operatorPubkey = (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key");
+  const network = (0, import_sdk9.networkFromArkadeInfo)(info);
+  const derived = deriveLightningSend({
+    quote,
     paymentHash: params.invoice.paymentHash,
-    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    senderPubkey,
+    refundPkScript: secrets.pkScript,
+    operatorPubkey,
     emulatorPubkey: (0, import_sdk9.toXOnly)(
       import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
-    senderPubkey,
-    receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: secrets.pkScript
-  };
-  const matched = matchQuotedLockup(
-    quote,
-    network.hrp,
-    serverPubkey,
-    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
-  );
-  const script = matched.script;
-  const address = matched.address;
-  const matchedTreeParams = {
-    ...treeParams,
-    ...matched.legacy !== void 0 && { legacy: matched.legacy }
-  };
+    claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
+    hrp: network.hrp
+  });
+  const { address, script, contractParams } = derived;
   assertFundable({
     quote,
     invoiceExpiresAt: params.invoice.expiresAt,
@@ -2363,12 +2532,12 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     // What the lockup must carry: the quote's `from_amount` — the invoice
     // PLUS the corridor's fee, never the bare invoice amount.
     fundAmount: quote.from_amount,
-    swapPkScript: script.pkScript,
+    swapPkScript: derived.swapPkScript,
     script,
     refundAddress,
     senderPubkey,
     secrets,
-    treeParams: matchedTreeParams
+    contractParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -2433,10 +2602,10 @@ function deriveOnchainSend(input) {
   if (refundLocktime === void 0 || htlcPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || receiverPkScriptHex === void 0) {
     throw new Error("onchain-send quote is missing a binding field");
   }
-  const treeParams = {
+  const contractParams = {
     solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
-    serverPubkey: input.serverPubkey,
+    operatorPubkey: input.operatorPubkey,
     paymentHash: input.paymentHash,
     claimDelay: input.claimDelay,
     emulatorPubkey: input.emulatorPubkey,
@@ -2447,8 +2616,8 @@ function deriveOnchainSend(input) {
   const { script, address } = matchQuotedLockup(
     quote,
     input.hrp,
-    input.serverPubkey,
-    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
   );
   const htlcParams = {
     paymentHash: input.paymentHash,
@@ -2470,7 +2639,7 @@ function deriveOnchainSend(input) {
     minConfirmations
   };
 }
-async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
+async function requestOnchainSend(wallet, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await (0, import_sdk10.provisionClaimSecret)(wallet, { preimage: params.preimage });
   if (secrets.mustPersistPreimage) {
@@ -2481,7 +2650,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
   const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const senderPubkey = secrets.pubkey;
   const [info, refundAddress] = await Promise.all([
-    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getArkadeInfo({ requireLive: true }),
     wallet.getAddress()
   ]);
   const quote = await transport.requestQuote(
@@ -2496,12 +2665,12 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk9.getNetwork)(info.network);
+  const network = (0, import_sdk9.networkFromArkadeInfo)(info);
   const derived = deriveOnchainSend({
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
+    operatorPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: (0, import_sdk9.toXOnly)(
       import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
@@ -2538,6 +2707,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     htlcParams: derived.htlcParams,
     l1Network: derived.l1Network,
     minConfirmations: derived.minConfirmations,
+    refundLocktime: derived.refundLocktime,
     senderPubkey,
     secrets
   };
@@ -2609,7 +2779,7 @@ var assertReceivable = (input) => {
     );
   }
 };
-function receiveVtxoScript(params) {
+function lightningReceiveContract(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
@@ -2617,7 +2787,7 @@ function receiveVtxoScript(params) {
   return new import_sdk9.VHTLC.ScriptV2({
     sender: params.solverPubkey,
     receiver: params.payoutPubkey,
-    server: params.serverPubkey,
+    server: params.operatorPubkey,
     preimageHash: (0, import_legacy2.ripemd160)(import_base10.hex.decode(params.paymentHash)),
     refundLocktime: BigInt(params.refundLocktime),
     unilateralClaimDelay: seconds(params.claimDelay),
@@ -2642,10 +2812,10 @@ 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 treeParams = {
+  const contractParams = {
     solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
-    serverPubkey: input.serverPubkey,
+    operatorPubkey: input.operatorPubkey,
     paymentHash: input.paymentHash,
     claimDelay: input.claimDelay,
     emulatorPubkey: input.emulatorPubkey,
@@ -2656,8 +2826,8 @@ function deriveLightningReceive(input) {
   const matched = matchQuotedLockup(
     quote,
     input.hrp,
-    input.serverPubkey,
-    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
   );
   return {
     address: matched.address,
@@ -2665,13 +2835,13 @@ function deriveLightningReceive(input) {
     script: matched.script,
     invoice,
     refundLocktime,
-    treeParams: {
-      ...treeParams,
+    contractParams: {
+      ...contractParams,
       ...matched.legacy !== void 0 && { legacy: matched.legacy }
     }
   };
 }
-async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
+async function requestLightningReceive(wallet, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await (0, import_sdk10.provisionClaimSecret)(wallet);
   if (secrets.mustPersistPreimage) {
@@ -2683,7 +2853,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
   const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getArkadeInfo({ requireLive: true }),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2702,13 +2872,13 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk9.getNetwork)(info.network);
+  const network = (0, import_sdk9.networkFromArkadeInfo)(info);
   const derived = deriveLightningReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
+    operatorPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: (0, import_sdk9.toXOnly)(
       import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
@@ -2742,7 +2912,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     payoutAddress,
     payoutPubkey,
     secrets,
-    treeParams: derived.treeParams
+    contractParams: derived.contractParams
   };
 }
 function deriveOnchainReceive(input) {
@@ -2757,10 +2927,10 @@ function deriveOnchainReceive(input) {
   if (refundLocktime === void 0 || claimPubkey === void 0 || htlcLocktime === void 0 || minConfirmations === void 0 || solverRefundPkScriptHex === void 0) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
-  const treeParams = {
+  const contractParams = {
     solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
-    serverPubkey: input.serverPubkey,
+    operatorPubkey: input.operatorPubkey,
     paymentHash: input.paymentHash,
     claimDelay: input.claimDelay,
     emulatorPubkey: input.emulatorPubkey,
@@ -2771,8 +2941,11 @@ function deriveOnchainReceive(input) {
   const { script, address } = matchQuotedLockup(
     quote,
     input.hrp,
-    input.serverPubkey,
-    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({
+      ...contractParams,
+      ...legacy !== void 0 && { legacy }
+    })
   );
   const htlc = onchainHtlcScript(
     {
@@ -2794,7 +2967,7 @@ function deriveOnchainReceive(input) {
     minConfirmations
   };
 }
-async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
+async function requestOnchainReceive(wallet, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await (0, import_sdk10.provisionClaimSecret)(wallet);
   if (secrets.mustPersistPreimage) {
@@ -2806,7 +2979,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   const paymentHash = import_base10.hex.encode(secrets.paymentHash);
   const payoutPubkey = secrets.pubkey;
   const [info, payoutAddress] = await Promise.all([
-    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
+    wallet.getArkadeInfo({ requireLive: true }),
     wallet.getAddress()
   ]);
   const claimPacket = await sealClaimPacket({
@@ -2826,14 +2999,14 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     })
   );
   assertQuotedAmount(quote, params.amountSide, params.amount);
-  const network = (0, import_sdk9.getNetwork)(info.network);
+  const network = (0, import_sdk9.networkFromArkadeInfo)(info);
   const derived = deriveOnchainReceive({
     quote,
     paymentHash,
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
+    operatorPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
     emulatorPubkey: (0, import_sdk9.toXOnly)(
       import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
@@ -2991,7 +3164,7 @@ function solverOnchainRail(deps) {
       }
       const negotiated = await deps.connect(
         rendezvous,
-        (transport) => requestOnchainSend(ctx.wallet, deps.arkServerUrl, transport, {
+        (transport) => requestOnchainSend(ctx.wallet, transport, {
           amount,
           amountSide: "to",
           payoutPubkey: deps.payoutPubkey,
@@ -3104,7 +3277,7 @@ function solverLightningRail(deps) {
       }
       const negotiated = await deps.connect(
         rendezvous,
-        (transport) => requestLightningSend(ctx.wallet, deps.arkServerUrl, transport, {
+        (transport) => requestLightningSend(ctx.wallet, transport, {
           invoice: facts,
           ...deps.emulatorPubkey ? { emulatorPubkey: deps.emulatorPubkey } : {}
         })
@@ -3157,16 +3330,450 @@ function solverLightningRail(deps) {
   };
 }
 
+// src/payment/lightning.ts
+var import_sdk14 = require("@arkade-os/sdk");
+
+// src/payment/swapRail.ts
+var import_sdk13 = require("@arkade-os/sdk");
+
+// src/client/errors.ts
+var AmbiguousDestination = class extends Error {
+  constructor(destination, detail) {
+    super(`cannot route ${JSON.stringify(destination)}: ${detail}`);
+    this.destination = destination;
+  }
+  destination;
+  name = "AmbiguousDestination";
+};
+var UnsupportedRoute = class extends Error {
+  name = "UnsupportedRoute";
+  give;
+  take;
+  constructor(detail, corridors = {}) {
+    super(`unsupported route: ${detail}`);
+    this.give = corridors.give;
+    this.take = corridors.take;
+  }
+};
+var DiscoverySnapshotUnavailable = class extends Error {
+  constructor(network, detail) {
+    super(`cannot resolve on ${network} offline: ${detail}`);
+    this.network = network;
+  }
+  network;
+  name = "DiscoverySnapshotUnavailable";
+};
+var AmountMismatch = class extends Error {
+  constructor(sources) {
+    super(`exactly one amount may be pinned; got ${sources[0]} and ${sources[1]}`);
+    this.sources = sources;
+  }
+  sources;
+  name = "AmountMismatch";
+};
+var AmountEncodingUnsupported = class extends Error {
+  constructor(field, value, detail, options) {
+    super(`${field}: ${detail}`, options);
+    this.field = field;
+    this.value = value;
+  }
+  field;
+  value;
+  name = "AmountEncodingUnsupported";
+};
+var QuoteVerificationFailed = class extends Error {
+  constructor(check, expected, actual, options) {
+    super(`quote failed the ${check} check \u2014 refusing to fund`, options);
+    this.check = check;
+    this.expected = expected;
+    this.actual = actual;
+  }
+  check;
+  name = "QuoteVerificationFailed";
+  expected;
+  actual;
+};
+var QuoteExpired = class extends Error {
+  constructor(quoteId, expiresAt, now) {
+    super(`quote ${quoteId} expired at ${expiresAt}, ${now - expiresAt} ago`);
+    this.quoteId = quoteId;
+    this.expiresAt = expiresAt;
+    this.now = now;
+  }
+  quoteId;
+  expiresAt;
+  now;
+  name = "QuoteExpired";
+};
+var MaxFeeExceeded = class extends Error {
+  constructor(quoteId, asset4, fee, maxFee) {
+    super(`fee ${fee} of ${asset4} exceeds the ${maxFee} ceiling`);
+    this.quoteId = quoteId;
+    this.asset = asset4;
+    this.fee = fee;
+    this.maxFee = maxFee;
+  }
+  quoteId;
+  asset;
+  fee;
+  maxFee;
+  name = "MaxFeeExceeded";
+};
+var InsufficientFunds = class extends Error {
+  constructor(asset4, required, available) {
+    super(
+      `funding needs ${required} of ${asset4}` + (available === void 0 ? "" : `, wallet holds ${available}`)
+    );
+    this.asset = asset4;
+    this.required = required;
+    this.available = available;
+  }
+  asset;
+  required;
+  name = "InsufficientFunds";
+  available;
+};
+var AcceptConflict = class extends Error {
+  constructor(quoteId, swapId, fields) {
+    super(`accept ${quoteId} conflicts with swap ${swapId} on ${fields.join(", ")}`);
+    this.quoteId = quoteId;
+    this.swapId = swapId;
+    this.fields = fields;
+  }
+  quoteId;
+  swapId;
+  fields;
+  name = "AcceptConflict";
+};
+var ClientDisposed = class extends Error {
+  constructor(method) {
+    super(`${method}() called after the client was disposed`);
+    this.method = method;
+  }
+  method;
+  name = "ClientDisposed";
+};
+var NotCancellable = class extends Error {
+  constructor(swapId) {
+    super(`swap ${swapId} is not a cancellable asset swap`);
+    this.swapId = swapId;
+  }
+  swapId;
+  name = "NotCancellable";
+};
+var InconsistentRoute = class extends Error {
+  constructor(asset4, destination) {
+    super(`destination ${JSON.stringify(destination)} is not on ${asset4}'s chain`);
+    this.asset = asset4;
+    this.destination = destination;
+  }
+  asset;
+  destination;
+  name = "InconsistentRoute";
+};
+var OperatorUnreachable = class extends Error {
+  name = "OperatorUnreachable";
+  constructor(detail, options) {
+    super(`cannot derive a covenant: ${detail}`, options);
+  }
+};
+var MissingCorridorDep = class extends Error {
+  constructor(corridor, dep) {
+    super(`the ${corridor} corridor has no ${dep}`);
+    this.corridor = corridor;
+    this.dep = dep;
+  }
+  corridor;
+  dep;
+  name = "MissingCorridorDep";
+};
+var SWAP_ERRORS = {
+  AmbiguousDestination,
+  UnsupportedRoute,
+  DiscoverySnapshotUnavailable,
+  AmountMismatch,
+  AmountEncodingUnsupported,
+  QuoteVerificationFailed,
+  SwapRefusal,
+  QuoteExpired,
+  MaxFeeExceeded,
+  InsufficientFunds,
+  AcceptConflict,
+  ClientDisposed,
+  NotCancellable,
+  InconsistentRoute,
+  OperatorUnreachable,
+  MissingCorridorDep
+};
+var SWAP_ERROR_NAMES = Object.keys(SWAP_ERRORS);
+function isSwapError(e, name) {
+  if (!(e instanceof Error)) return false;
+  const table = SWAP_ERRORS;
+  const ctor = table[e.name];
+  if (ctor === void 0 || !(e instanceof ctor)) return false;
+  return name === void 0 || e.name === name;
+}
+
+// src/client/sats.ts
+var satsOf = (value, field) => {
+  if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new AmountEncodingUnsupported(
+      field,
+      `${value}`,
+      "outside the non-negative safe-integer window core's payment amounts are numbers in"
+    );
+  }
+  return Number(value);
+};
+
+// src/payment/status.ts
+var PAYMENT_STATUS = {
+  /** Persisted, funding not broadcast. */
+  accepted: "pending",
+  funding: "pending",
+  /** The lockup is funded. Nothing has emitted `"sent"` in core since the
+   *  `onchain-swap` rail left with `packages/boltz-swap`. */
+  funded: "sent",
+  /** Asset swaps only: an unfilled offer. */
+  open: "pending",
+  /** Asset swaps only. */
+  filled: "settled",
+  /** The trader's L1 claim on `arkade -> onchain`. */
+  claimed: "settled",
+  /** Terminal success on `arkade -> lightning`: the solver's hash-verified
+   *  spend IS the invoice being paid. */
+  paid: "settled",
+  cancelling: "pending",
+  /** Value returned, and the router has no non-loss terminal to say so with. */
+  cancelled: "failed",
+  /** Terminal HERE, not at `refunded` — see the module docblock. */
+  refunding: "failed",
+  /** The trader's value came back. Reaches `onUpdate`, not the handle. */
+  refunded: "failed",
+  /** The solver reclaimed a receive-leg lockup: a loss, and not `refunded`. */
+  lapsed: "failed",
+  /** Never retried silently; `client.recover` drives it. */
+  needs_recovery: "failed",
+  failed: "failed"
+};
+var paymentStatusOf = (outcome) => PAYMENT_STATUS[outcome];
+var isTerminalStatus = (status) => status === "settled" || status === "failed";
+
+// src/payment/swapRail.ts
+var SwapPaymentFailedError = class extends Error {
+  constructor(railId, outcome, swap) {
+    super(
+      `${railId}: swap ${swap.id} ended ${outcome}` + (swap.failure === void 0 ? "" : `: ${swap.failure}`) + (swap.blockedReason === void 0 ? "" : ` (${swap.blockedReason})`)
+    );
+    this.railId = railId;
+    this.outcome = outcome;
+    this.swap = swap;
+  }
+  railId;
+  outcome;
+  swap;
+  name = "SwapPaymentFailedError";
+};
+var unroutable = (error) => isSwapError(error, "UnsupportedRoute") || isSwapError(error, "AmbiguousDestination");
+var railAvailable = async (client, input) => {
+  try {
+    return (await client.resolve(input)).eligible > 0;
+  } catch (error) {
+    if (unroutable(error)) return false;
+    throw error;
+  }
+};
+var receiverExact = (railId, parts) => {
+  if (parts.total !== parts.amount + parts.fee) {
+    throw new Error(
+      `${railId}: ${parts.total} leaving the wallet is not ${parts.amount} delivered plus ${parts.fee} in fees \u2014 the quote is not receiver-exact`
+    );
+  }
+  return {
+    amount: satsOf(parts.amount, `${railId}.amount`),
+    fee: satsOf(parts.fee, `${railId}.fee`),
+    total: satsOf(parts.total, `${railId}.total`)
+  };
+};
+var resultOf = (railId, swap) => ({
+  railId,
+  // The tagged public form M6 minted — round-trippable to `client.swaps()`,
+  // which is where the outcomes past this handle's terminal one are read.
+  swapId: swap.id,
+  // The transaction that left THIS wallet, which is what `txid` means on
+  // every other rail. A swap's later legs — the solver's fill, the trader's
+  // L1 claim — are the client's to report, not the handle's.
+  ...swap.fundingTxid === void 0 ? {} : { txid: swap.fundingTxid }
+});
+var swapHandle = async (railId, client, quote) => (0, import_sdk13.makeHandle)(railId, async (emit) => {
+  const accepted = await client.accept(quote);
+  return await new Promise((resolve, reject) => {
+    let finished = false;
+    let unsubscribe;
+    const listener = (update) => {
+      if (finished || update.swap.id !== accepted.id) return;
+      const status = paymentStatusOf(update.outcome);
+      const result = resultOf(railId, update.swap);
+      if (!isTerminalStatus(status)) {
+        emit({ status, result });
+        return;
+      }
+      finished = true;
+      unsubscribe?.();
+      if (status === "settled") {
+        emit({ status, result });
+        resolve(result);
+        return;
+      }
+      reject(new SwapPaymentFailedError(railId, update.outcome, update.swap));
+    };
+    unsubscribe = client.onUpdate(listener);
+    if (finished) unsubscribe();
+  });
+});
+
+// src/payment/lightning.ts
+var LIGHTNING_RAIL = "lightning";
+var inputFor = (invoice, amount) => ({
+  to: invoice,
+  ...amount === void 0 ? {} : { amount: BigInt(amount), amountOn: "take" }
+});
+function lightningRail(client) {
+  return {
+    id: LIGHTNING_RAIL,
+    // Amount-blind and non-throwing: classification only, which is what
+    // keeps `match` from being a second gate on top of `available`.
+    match: (req) => (0, import_sdk14.invoiceTarget)(req.raw) !== void 0,
+    available: async (req) => {
+      const invoice = (0, import_sdk14.invoiceTarget)(req.raw);
+      if (invoice === void 0) return false;
+      return railAvailable(client, inputFor(invoice, req.amount));
+    },
+    quote: async (req) => {
+      const invoice = (0, import_sdk14.invoiceTarget)(req.raw);
+      if (invoice === void 0) {
+        throw new Error(`${LIGHTNING_RAIL}: the request carries no BOLT11 invoice`);
+      }
+      const quote = await client.quote(inputFor(invoice, req.amount));
+      const amounts = receiverExact(LIGHTNING_RAIL, {
+        amount: quote.take.amount,
+        fee: quote.fee.amount,
+        total: quote.give.amount
+      });
+      return {
+        railId: LIGHTNING_RAIL,
+        ...amounts,
+        meta: {
+          quoteId: quote.id,
+          // A `RouteQuote` carries no expiry of its own, so a held one
+          // can outlive the terms behind it. This is where a caller
+          // can see that; `send()` refuses with `QuoteExpired` rather
+          // than silently re-quoting.
+          expiresAt: quote.expiresAt,
+          ...quote.refundLocktime === void 0 ? {} : { refundLocktime: quote.refundLocktime },
+          ...quote.solver === void 0 ? {} : { solver: quote.solver },
+          ...quote.lock === void 0 ? {} : { paymentHash: quote.lock.hash },
+          market: quote.market.key
+        },
+        send: () => swapHandle(LIGHTNING_RAIL, client, quote)
+      };
+    }
+  };
+}
+
+// src/payment/onchainSwap.ts
+var import_sdk15 = require("@arkade-os/sdk");
+var ONCHAIN_SWAP_RAIL = "onchain-swap";
+var claimFeeSats = (deps) => BigInt(Math.ceil((deps.claimVsize ?? ONCHAIN_CLAIM_VSIZE) * deps.claimFeeRateSatVb));
+function onchainSwapRail(client, deps) {
+  if (!Number.isFinite(deps.claimFeeRateSatVb) || deps.claimFeeRateSatVb <= 0) {
+    throw new Error(
+      `${ONCHAIN_SWAP_RAIL}: claimFeeRateSatVb must be positive, got ${deps.claimFeeRateSatVb}`
+    );
+  }
+  const claimFee = claimFeeSats(deps);
+  const inputFor2 = (address, amount) => ({
+    to: address,
+    amount: BigInt(amount) + claimFee,
+    amountOn: "take"
+  });
+  return {
+    id: ONCHAIN_SWAP_RAIL,
+    match: (req) => (0, import_sdk15.btcTarget)(req.raw) !== void 0,
+    available: async (req) => {
+      const address = (0, import_sdk15.btcTarget)(req.raw);
+      if (address === void 0) return false;
+      const amount = (0, import_sdk15.tryResolveSendAmount)(req.raw, req.amount);
+      if (amount === void 0) return false;
+      return railAvailable(client, inputFor2(address, amount));
+    },
+    quote: async (req) => {
+      const address = (0, import_sdk15.btcTarget)(req.raw);
+      if (address === void 0) {
+        throw new Error(`${ONCHAIN_SWAP_RAIL}: the request carries no bitcoin address`);
+      }
+      const amount = (0, import_sdk15.resolveSendAmount)(ONCHAIN_SWAP_RAIL, req.raw, req.amount);
+      const quote = await client.quote(inputFor2(address, amount));
+      const amounts = receiverExact(ONCHAIN_SWAP_RAIL, {
+        // What lands at the address, which is the HTLC the solver locks
+        // minus the claim this wallet will broadcast to take it.
+        amount: quote.take.amount - claimFee,
+        // Both halves of the cost, inside one number: the solver's
+        // spread, and the claim the trader pays for out of the payout.
+        fee: quote.fee.amount + claimFee,
+        total: quote.give.amount
+      });
+      return {
+        railId: ONCHAIN_SWAP_RAIL,
+        ...amounts,
+        meta: {
+          quoteId: quote.id,
+          expiresAt: quote.expiresAt,
+          ...quote.refundLocktime === void 0 ? {} : { refundLocktime: quote.refundLocktime },
+          ...quote.solver === void 0 ? {} : { solver: quote.solver },
+          ...quote.lock === void 0 ? {} : { paymentHash: quote.lock.hash },
+          market: quote.market.key,
+          /** The estimate folded into `fee`, so a caller can see it. */
+          claimFeeSats: Number(claimFee),
+          /** What the solver locks on L1, before the claim's fee. */
+          htlcAmountSats: Number(quote.take.amount)
+        },
+        send: () => swapHandle(ONCHAIN_SWAP_RAIL, client, quote)
+      };
+    }
+  };
+}
+
+// src/payment/router.ts
+var import_sdk16 = require("@arkade-os/sdk");
+var SWAP_ROUTER_PRIORITY = [
+  "ark",
+  LIGHTNING_RAIL,
+  ONCHAIN_SWAP_RAIL,
+  "onchain"
+];
+function createSwapPaymentRouter(wallet, client, config) {
+  return new import_sdk16.PaymentRouter({
+    wallet,
+    prefs: { priority: [...SWAP_ROUTER_PRIORITY], ...config.prefs }
+  }).use((0, import_sdk16.arkRail)()).use((0, import_sdk16.onchainRail)()).use(lightningRail(client)).use(
+    onchainSwapRail(client, {
+      claimFeeRateSatVb: config.claimFeeRateSatVb,
+      ...config.claimVsize === void 0 ? {} : { claimVsize: config.claimVsize }
+    })
+  );
+}
+
 // src/claim.ts
 var import_base14 = require("@scure/base");
 var import_legacy3 = require("@noble/hashes/legacy.js");
 var import_sha25 = require("@noble/hashes/sha2.js");
-var import_sdk14 = require("@arkade-os/sdk");
+var import_sdk18 = require("@arkade-os/sdk");
 
 // src/refund.ts
 var import_base13 = require("@scure/base");
 var import_sha24 = require("@noble/hashes/sha2.js");
-var import_sdk13 = require("@arkade-os/sdk");
+var import_sdk17 = 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"];
@@ -3186,6 +3793,15 @@ async function awaitRfqResolution(transport, rfqId, options = {}) {
     await sleep2(pollMs);
   }
 }
+var walletOperator = (wallet) => {
+  let broadcaster;
+  const broadcasting = () => broadcaster ??= wallet.getArkadeBroadcaster();
+  return {
+    getInfo: () => wallet.getArkadeInfo({ requireLive: true }),
+    submitTx: async (...args) => (await broadcasting()).submitTx(...args),
+    finalizeTx: async (...args) => (await broadcasting()).finalizeTx(...args)
+  };
+};
 var LockupNeedsRecoveryError = class extends Error {
   name = "LockupNeedsRecoveryError";
   reason = "needs_recovery";
@@ -3197,11 +3813,10 @@ var LockupNeedsRecoveryError = class extends Error {
    * into one settlement with no CLTV awareness, so an early attempt can fail
    * the whole batch — including unrelated outputs that were otherwise fine.
    *
-   * Exposed as a value, not only inside the message, so a caller can encode
-   * `packages/boltz-swap`'s "pre-CLTV recoverable → skipped" rule without
-   * parsing prose. Seconds-based locktimes mature against the chain tip's
-   * timestamp rather than wall clock, so treat this as a floor to wait past,
-   * not an exact alarm.
+   * Exposed as a value, not only inside the message, so a caller can skip
+   * pre-CLTV recoverable outputs without parsing prose. Seconds-based
+   * locktimes mature against the chain tip's timestamp rather than wall
+   * clock, so treat this as a floor to wait past, not an exact alarm.
    */
   recoverableAfter;
   constructor(outpoints, recoverableAfter) {
@@ -3241,14 +3856,14 @@ async function findLockupVtxos(indexer, swapPkScript) {
 }
 var hashesTo = (candidate, paymentHash) => import_base13.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
-  ...(0, import_sdk13.getArkPsbtFields)(tx, inputIndex, import_sdk13.ConditionWitness).flat(),
+  ...(0, import_sdk17.getArkPsbtFields)(tx, inputIndex, import_sdk17.ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
 ];
 async function readLockupFate(indexer, input) {
   const { vtxos } = await indexer.getVtxos({ scripts: [import_base13.hex.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
-  const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk13.hasTerminalSpend)(vtxo));
+  const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk17.hasTerminalSpend)(vtxo));
   if (exited.length > 0) {
     return {
       fate: "exited",
@@ -3258,11 +3873,11 @@ async function readLockupFate(indexer, input) {
   const spentBy = /* @__PURE__ */ new Map();
   let everySpendNamed = true;
   for (const vtxo of all) {
-    if (!(0, import_sdk13.hasTerminalSpend)(vtxo)) return { fate: "open" };
+    if (!(0, import_sdk17.hasTerminalSpend)(vtxo)) return { fate: "open" };
     if (vtxo.spentBy)
       spentBy.set(vtxo.spentBy, {
         checkpointTxid: vtxo.spentBy,
-        arkTxid: vtxo.arkTxId
+        txid: vtxo.arkTxId
       });
     else everySpendNamed = false;
   }
@@ -3272,7 +3887,7 @@ async function readLockupFate(indexer, input) {
   for (const raw of txs) {
     let tx;
     try {
-      tx = import_sdk13.Transaction.fromPSBT(import_base13.base64.decode(raw));
+      tx = import_sdk17.Transaction.fromPSBT(import_base13.base64.decode(raw));
     } catch {
       continue;
     }
@@ -3291,32 +3906,32 @@ async function readLockupFate(indexer, input) {
   }
   return everySpendNamed && observed.size === spentBy.size ? { fate: "returned", spends } : { fate: "unknown" };
 }
-async function pushRefundWithoutReceiver(ark, input) {
+async function pushRefundWithoutReceiver(operator, input) {
   if (input.vtxos.length === 0) throw new Error("nothing to refund: no funded outputs");
   const swept = input.vtxos.filter((vtxo) => vtxo.recoverable);
   if (swept.length > 0) {
     throw new LockupNeedsRecoveryError(
       swept.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`),
-      input.script.options.refundLocktime
+      input.contract.options.refundLocktime
     );
   }
-  const refundPkScript = input.refundPkScript ?? input.script.options.nonInteractiveParameters?.senderPkScript;
+  const refundPkScript = input.refundPkScript ?? input.contract.options.nonInteractiveParameters?.senderPkScript;
   if (!refundPkScript) {
     throw new Error(
       "no refund destination: the contract carries no emulator covenant suite, so pass refundPkScript explicitly"
     );
   }
-  const info = await ark.getInfo();
-  let serverUnrollScript;
+  const info = await operator.getInfo();
+  let operatorUnrollScript;
   try {
-    serverUnrollScript = import_sdk13.CSVMultisigTapscript.decode(import_base13.hex.decode(info.checkpointTapscript));
+    operatorUnrollScript = import_sdk17.CSVMultisigTapscript.decode(import_base13.hex.decode(info.checkpointTapscript));
   } catch {
-    throw new Error("invalid checkpointTapscript from the Arkade server");
+    throw new Error("invalid checkpointTapscript from the operator");
   }
-  const leaf = input.script.refundWithoutReceiver();
-  const tapTree = input.script.encode();
+  const leaf = input.contract.refundWithoutReceiver();
+  const tapTree = input.contract.encode();
   const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
-  const { arkTx, checkpoints } = (0, import_sdk13.buildOffchainTx)(
+  const { arkTx: tx, checkpoints } = (0, import_sdk17.buildOffchainTx)(
     input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -3325,15 +3940,15 @@ async function pushRefundWithoutReceiver(ark, input) {
       tapTree
     })),
     [{ script: refundPkScript, amount: BigInt(amount) }],
-    serverUnrollScript
+    operatorUnrollScript
   );
-  const signedArkTx = await input.sender.sign(arkTx);
-  const submitted = await ark.submitTx(
-    import_base13.base64.encode(signedArkTx.toPSBT()),
+  const signedTx = await input.sender.sign(tx);
+  const submitted = await operator.submitTx(
+    import_base13.base64.encode(signedTx.toPSBT()),
     checkpoints.map((c) => import_base13.base64.encode(c.toPSBT()))
   );
-  (0, import_sdk13.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
-  const matched = (0, import_sdk13.matchServerCheckpoints)(
+  (0, import_sdk17.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
+  const matched = (0, import_sdk17.matchServerCheckpoints)(
     submitted.signedCheckpointTxs,
     checkpoints,
     "refundWithoutReceiver"
@@ -3343,11 +3958,11 @@ async function pushRefundWithoutReceiver(ark, input) {
       async ({ server }) => import_base13.base64.encode((await input.sender.sign(server, [0])).toPSBT())
     )
   );
-  await ark.finalizeTx(submitted.arkTxid, finalCheckpoints);
-  return { arkTxid: submitted.arkTxid, amount };
+  await operator.finalizeTx(submitted.arkTxid, finalCheckpoints);
+  return { txid: submitted.arkTxid, amount };
 }
 var REFUND_MTP_LAG_SECONDS = 2 * 60 * 60;
-async function refundIfUnresolved(transport, ark, indexer, input) {
+async function refundIfUnresolved(transport, operator, indexer, input) {
   const pollMs = input.pollMs ?? 5e3;
   const now = input.now ?? (() => Math.floor(Date.now() / 1e3));
   const attemptDeadline = input.attemptDeadline ?? input.refundLocktime + REFUND_MTP_LAG_SECONDS;
@@ -3358,7 +3973,7 @@ async function refundIfUnresolved(transport, ark, indexer, input) {
       let fate = { fate: "unknown" };
       try {
         fate = await readLockupFate(indexer, {
-          swapPkScript: input.script.pkScript,
+          swapPkScript: input.contract.pkScript,
           paymentHash: input.paymentHash
         });
       } catch {
@@ -3370,11 +3985,11 @@ async function refundIfUnresolved(transport, ark, indexer, input) {
           status
         };
       }
-      const vtxos = await findLockupVtxos(indexer, input.script.pkScript);
+      const vtxos = await findLockupVtxos(indexer, input.contract.pkScript);
       if (vtxos.length === 0) return { outcome: "nothing_to_refund", status };
       try {
-        const pushed = await pushRefundWithoutReceiver(ark, {
-          script: input.script,
+        const pushed = await pushRefundWithoutReceiver(operator, {
+          contract: input.contract,
           sender: input.sender,
           vtxos,
           refundPkScript: input.refundPkScript
@@ -3417,13 +4032,13 @@ var assertFiniteAmount = (value, reason, label) => {
   error.reason = reason;
   throw error;
 };
-async function pushClaim(ark, input) {
+async function pushClaim(operator, input) {
   if (input.vtxos.length === 0) throw new Error("nothing to claim: no funded outputs");
   const swept = input.vtxos.filter((vtxo) => vtxo.recoverable);
   if (swept.length > 0) {
     throw new LockupNeedsRecoveryError(
       swept.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`),
-      input.script.options.refundLocktime
+      input.contract.options.refundLocktime
     );
   }
   const locked = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
@@ -3434,22 +4049,22 @@ async function pushClaim(ark, input) {
       throw new LockupAmountMismatchError(input.expectedAmount, locked);
     }
   }
-  const committed = input.script.options.preimageHash;
+  const committed = input.contract.options.preimageHash;
   if (import_base14.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base14.hex.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
-  const info = await ark.getInfo();
-  let serverUnrollScript;
+  const info = await operator.getInfo();
+  let operatorUnrollScript;
   try {
-    serverUnrollScript = import_sdk14.CSVMultisigTapscript.decode(import_base14.hex.decode(info.checkpointTapscript));
+    operatorUnrollScript = import_sdk18.CSVMultisigTapscript.decode(import_base14.hex.decode(info.checkpointTapscript));
   } catch {
-    throw new Error("invalid checkpointTapscript from the Arkade server");
+    throw new Error("invalid checkpointTapscript from the operator");
   }
-  const leaf = input.script.claim();
-  const tapTree = input.script.encode();
-  const arkTxid = await (0, import_sdk14.signAndSubmitOffchainTx)({
-    identity: (0, import_sdk14.claimWithPreimageIdentity)(input.receiver, input.preimage),
-    provider: ark,
+  const leaf = input.contract.claim();
+  const tapTree = input.contract.encode();
+  const txid = await (0, import_sdk18.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk18.claimWithPreimageIdentity)(input.receiver, input.preimage),
+    provider: operator,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -3460,10 +4075,10 @@ async function pushClaim(ark, input) {
     // One aggregate output: unlike the covenant refund, this leaf inspects
     // nothing about the output set.
     outputs: [{ script: input.destinationPkScript, amount: BigInt(locked) }],
-    serverUnrollScript,
-    verifyServerSignatures: { serverPubkey: input.script.options.server }
+    serverUnrollScript: operatorUnrollScript,
+    verifyServerSignatures: { serverPubkey: input.contract.options.server }
   });
-  return { arkTxid, amount: locked };
+  return { txid, amount: locked };
 }
 async function awaitLockupFunding(indexer, swapPkScript, options = {}) {
   const pollMs = options.pollMs ?? 5e3;
@@ -3478,13 +4093,13 @@ async function awaitLockupFunding(indexer, swapPkScript, options = {}) {
     await sleep3(pollMs);
   }
 }
-async function claimReceiveLockup(indexer, ark, input) {
+async function claimReceiveLockup(indexer, operator, input) {
   const vtxos = await awaitLockupFunding(indexer, input.swapPkScript, {
     pollMs: input.pollMs,
     deadline: input.deadline
   });
-  return pushClaim(ark, {
-    script: input.script,
+  return pushClaim(operator, {
+    contract: input.contract,
     receiver: input.receiver,
     preimage: input.preimage,
     vtxos,
@@ -3495,7 +4110,7 @@ async function claimReceiveLockup(indexer, ark, input) {
 }
 
 // src/refundBlocked.ts
-var import_sdk15 = require("@arkade-os/sdk");
+var import_sdk19 = require("@arkade-os/sdk");
 var RefundNotLocallyPossibleError = class extends Error {
   constructor(reason, message, options) {
     super(message, options);
@@ -3512,16 +4127,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
     );
   }
   try {
-    return await (0, import_sdk15.contractSigner)(wallet, record.signingDescriptor);
+    return await (0, import_sdk19.contractSigner)(wallet, record.signingDescriptor);
   } catch (cause) {
-    if (cause instanceof import_sdk15.WalletCannotSignError) {
+    if (cause instanceof import_sdk19.WalletCannotSignError) {
       throw new RefundNotLocallyPossibleError(
         "unsignable-wallet",
         `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
         { cause }
       );
     }
-    if (cause instanceof import_sdk15.ForeignDescriptorError) {
+    if (cause instanceof import_sdk19.ForeignDescriptorError) {
       throw new RefundNotLocallyPossibleError(
         "foreign-descriptor",
         `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -3535,8 +4150,8 @@ async function senderIdentityForSwapRecord(wallet, record) {
 // src/arkadeRefunder.ts
 function arkadeRefunder(deps) {
   return async (swap) => {
-    const script = swap.lockup?.script;
-    if (!script) {
+    const contract = swap.lockup?.script;
+    if (!contract) {
       throw new Error(
         `swap ${swap.rfqId} carries no lockup covenant, so its refund cannot be built`
       );
@@ -3551,7 +4166,7 @@ function arkadeRefunder(deps) {
       );
     }
     const sender = await senderIdentityForSwapRecord(deps.wallet, rfqSignerOf(record) ?? {});
-    return pushRefundWithoutReceiver(deps.ark, { script, sender, vtxos });
+    return pushRefundWithoutReceiver(deps.operator, { contract, sender, vtxos });
   };
 }
 
@@ -3572,6 +4187,14 @@ function nextOnchainAction(input) {
       return input.htlcLocktime - input.now >= ONCHAIN_CLAIM_MARGIN_SECONDS ? "claim" : "claim_window_closed";
   }
 }
+var RFQ_CONFIGURATION_REFUSAL = {
+  noClaimLockupCallback: "no claimLockup callback is wired, so this wallet cannot claim the lockup",
+  noCallbacksForClaim: "no callbacks are wired, so this wallet cannot claim the lockup",
+  noClaimOnchainCallback: "no claimOnchain callback is wired, so this wallet cannot claim the L1 fill",
+  autoActionsDisabled: "automatic actions are disabled, so this wallet will not push the refund",
+  noCallbacksForRefund: "no callbacks are wired, so this wallet cannot push the refund"
+};
+var RFQ_CONFIGURATION_REFUSALS = Object.values(RFQ_CONFIGURATION_REFUSAL);
 var RfqSwapOriginRequired = class extends Error {
   /** The swap that could not be admitted. */
   rfqId;
@@ -3622,20 +4245,6 @@ var RfqSwapManager = class {
    * sign may well have been restored.
    */
   refundRefused = /* @__PURE__ */ new Set();
-  /**
-   * The last error a receive swap's claim callback threw, by rfqId.
-   *
-   * Kept only to tell two terminal outcomes apart once the claim window
-   * shuts: a swap whose claim was attempted and kept failing ends `failed`
-   * with that reason, while one that simply never became claimable ends
-   * `refunded`. Without it a broken claim callback would resolve a caller's
-   * {@link waitForSwapCompletion} as an ordinary unwind.
-   *
-   * Process-local, like {@link refundRefused}: after a restart the same swap
-   * ends `refunded` instead, which costs the caller a reason and nothing else
-   * — every throw was already reported through `onSwapFailed` as it happened.
-   */
-  lastClaimError = /* @__PURE__ */ new Map();
   /**
    * The lockup outpoints a receive swap's claim callback has already been
    * handed, by rfqId.
@@ -3947,6 +4556,19 @@ var RfqSwapManager = class {
   async getPendingSwaps() {
     return [...this.monitored.values()];
   }
+  /**
+   * Every swap this manager holds — {@link getPendingSwaps} plus the ones
+   * that already ended. The two sets are disjoint: a swap leaves `monitored`
+   * as it enters `finished`.
+   *
+   * The finished half is what this process has seen, which after
+   * {@link restoreFromRepository} is the stored history minus what retention
+   * pruned. A manager that has restored nothing answers with the live swaps
+   * alone.
+   */
+  async getAllSwaps() {
+    return [...this.monitored.values(), ...this.finished.values()];
+  }
   async hasSwap(rfqId) {
     return this.monitored.has(rfqId);
   }
@@ -4016,7 +4638,6 @@ var RfqSwapManager = class {
     if (swap) this.byLockupScript.delete(import_base15.hex.encode(swap.lockupPkScript));
     this.monitored.delete(rfqId);
     this.refundRefused.delete(rfqId);
-    this.lastClaimError.delete(rfqId);
     this.claimedOutpoints.delete(rfqId);
   }
   /**
@@ -4225,14 +4846,14 @@ var RfqSwapManager = class {
       return this.claimIfFunded(swap, vtxos);
     }
     if (now < swap.refundLocktime + REFUND_MTP_LAG_SECONDS) {
-      if (swap.claimArkTxid) return;
+      if (swap.claimTxid) return;
       return this.block(
         swap,
         "the claim window closed with the lockup unclaimed \u2014 only the solver can act now"
       );
     }
-    const failure = this.lastClaimError.get(swap.rfqId);
-    if (failure && !swap.claimArkTxid) {
+    const failure = swap.claimFailure;
+    if (failure && !swap.claimTxid) {
       return this.fail(swap, new Error(failure));
     }
     this.setState(swap, "refunded");
@@ -4247,7 +4868,7 @@ var RfqSwapManager = class {
    */
   async claimIfFunded(swap, vtxos) {
     if (vtxos.length === 0) return this.unblock(swap);
-    const partiallyClaimed = swap.claimArkTxid !== void 0;
+    const partiallyClaimed = swap.claimTxid !== void 0;
     if (partiallyClaimed && !this.hasUnclaimedOutpoint(swap.rfqId, vtxos)) {
       return;
     }
@@ -4269,21 +4890,22 @@ var RfqSwapManager = class {
     if (!this.callbacks || !this.callbacks.claimLockup) {
       return this.block(
         swap,
-        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.callbacks ? RFQ_CONFIGURATION_REFUSAL.noClaimLockupCallback : RFQ_CONFIGURATION_REFUSAL.noCallbacksForClaim
       );
     }
     this.setState(swap, "claimable");
     if (!this.config.enableAutoActions) return;
     try {
-      const { arkTxid } = await this.callbacks.claimLockup(swap, vtxos, { partiallyClaimed });
-      this.lastClaimError.delete(swap.rfqId);
+      const { txid } = await this.callbacks.claimLockup(swap, vtxos, { partiallyClaimed });
+      delete swap.claimFailure;
       this.rememberClaimed(swap.rfqId, vtxos);
-      swap.claimArkTxid = arkTxid;
+      swap.claimTxid = txid;
       this.touch(swap);
       this.setState(swap, "claimed");
       this.emitAction(swap, "claimLockup");
     } catch (error) {
-      this.lastClaimError.set(swap.rfqId, errorMessage(error));
+      swap.claimFailure = errorMessage(error);
+      this.touch(swap);
       this.emitFailed(swap, error);
     }
   }
@@ -4320,10 +4942,7 @@ 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"
-        );
+        this.block(swap, RFQ_CONFIGURATION_REFUSAL.noClaimOnchainCallback);
         return "handled";
       }
       this.setOnchainState(swap, "claimable");
@@ -4363,14 +4982,14 @@ var RfqSwapManager = class {
     if (!this.config.enableAutoActions || !this.callbacks) {
       return this.block(
         swap,
-        this.callbacks ? "automatic actions are disabled, so this wallet will not push the refund" : "no callbacks are wired, so this wallet cannot push the refund"
+        this.callbacks ? RFQ_CONFIGURATION_REFUSAL.autoActionsDisabled : RFQ_CONFIGURATION_REFUSAL.noCallbacksForRefund
       );
     }
     this.unblock(swap);
     try {
       const pushed = await this.callbacks.refundArkade(swap);
       if (pushed) {
-        swap.refundArkTxid = pushed.arkTxid;
+        swap.refundTxid = pushed.txid;
         this.touch(swap);
       }
       this.setState(swap, "refunded");
@@ -4443,7 +5062,7 @@ var RfqSwapManager = class {
   /**
    * Record which ark transactions ended the lockup.
    *
-   * Only the ones the indexer actually named: `LockupSpend.arkTxid` is
+   * Only the ones the indexer actually named: `LockupSpend.txid` 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.
@@ -4453,9 +5072,9 @@ var RfqSwapManager = class {
    * 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;
+    const txids = spends.map((spend) => spend.txid).filter((txid) => txid !== void 0);
+    if (txids.length === 0) return;
+    swap.lockupSpendTxids = txids;
     this.touch(swap);
   }
   touch(swap) {
@@ -4466,6 +5085,7 @@ var RfqSwapManager = class {
     if (swap.state === state) return;
     const previous = swap.state;
     if (previous === "needs_counterparty") delete swap.blockedReason;
+    if (isRfqSwapTerminal(state)) delete swap.claimFailure;
     swap.state = state;
     this.touch(swap);
     notify(this.swapUpdateListeners, (listener) => listener(swap, previous));
@@ -4536,10 +5156,9 @@ var RfqSwapManager = class {
   /**
    * Drop a terminal swap from monitoring and report it exactly once.
    *
-   * `onSwapCompleted` and `onSwapFailed` are mutually exclusive here, unlike
-   * Boltz's manager, which fires completion for every swap that leaves
-   * monitoring including the failed ones — a listener named "completed" that
-   * also fires on failure is a trap worth not inheriting.
+   * `onSwapCompleted` and `onSwapFailed` are mutually exclusive here: a
+   * listener named "completed" that also fires on failure is a trap, so a
+   * swap that leaves monitoring reports through exactly one of them.
    */
   finalize(swap) {
     if (!this.monitored.has(swap.rfqId)) return;
@@ -4575,7 +5194,7 @@ var traderClaimTxid = (swap) => {
     case "onchain_send":
       return swap.claimTxid;
     case "lightning_receive":
-      return swap.claimArkTxid;
+      return swap.claimTxid;
     default:
       return void 0;
   }
@@ -4585,36 +5204,199 @@ var outcomeOf = (swap) => {
   const lostReceive = swap.kind === "lightning_receive" && swap.state === "refunded";
   return {
     state: swap.state,
-    txid: lostReceive ? swap.refundArkTxid : traderClaimTxid(swap) ?? swap.refundArkTxid
+    txid: lostReceive ? swap.refundTxid : traderClaimTxid(swap) ?? swap.refundTxid
   };
 };
 var errorMessage = (error) => error instanceof Error ? error.message : String(error);
 var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 
 // src/activity.ts
-var import_sdk16 = require("@arkade-os/sdk");
+var import_sdk22 = require("@arkade-os/sdk");
 var import_base16 = require("@scure/base");
+
+// src/client/corridors/lightning.ts
+var import_sdk20 = require("@arkade-os/sdk");
+var INVOICE_HRPS = [
+  ["lnbcrt", ["regtest"]],
+  ["lntbs", ["signet", "mutinynet"]],
+  ["lnbc", ["bitcoin"]],
+  ["lntb", ["testnet"]]
+];
+var networksOfInvoiceHrp = (raw) => {
+  const lower = raw.toLowerCase();
+  return INVOICE_HRPS.find(([hrp]) => lower.startsWith(hrp))?.[1];
+};
+var PAYMENT_HASH = /^[0-9a-f]{64}$/;
+var LIGHTNING_DRIVE = {
+  give: {
+    lockups: [{ covenant: "arkade_lockup", owner: "solver", deadline: "refund_locktime" }],
+    actions: ["claimLockup"],
+    seams: ["indexer"]
+  },
+  take: {
+    lockups: [{ covenant: "arkade_lockup", owner: "trader", deadline: "refund_locktime" }],
+    actions: ["refundArkade"],
+    seams: ["indexer"]
+  }
+};
+var lightningCorridor = Object.assign(
+  (deps) => ({
+    corridor: "lightning",
+    deps,
+    drive: LIGHTNING_DRIVE,
+    matches(raw) {
+      const invoice = (0, import_sdk20.invoiceTarget)(raw);
+      if (invoice === void 0) return void 0;
+      const networks = networksOfInvoiceHrp(invoice);
+      if (networks === void 0) {
+        return { refused: "this invoice's network prefix names no network this SDK knows" };
+      }
+      if (!networks.includes(deps.networkName)) {
+        return {
+          refused: `this is a ${networks.join(" or ")} invoice and the wallet is on ${deps.networkName}`
+        };
+      }
+      let facts;
+      try {
+        facts = deps.decode(invoice);
+        if (!PAYMENT_HASH.test(facts.paymentHash)) {
+          return { refused: "the decoded invoice carries no usable payment hash" };
+        }
+      } catch (error) {
+        return {
+          refused: `the invoice did not decode: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      if (!Number.isSafeInteger(facts.expiresAt)) {
+        return { refused: "the decoded invoice carries no usable expiry" };
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      if (facts.expiresAt <= now) {
+        return { refused: `the invoice expired ${now - facts.expiresAt}s ago` };
+      }
+      if (!Number.isSafeInteger(facts.amountSats) || facts.amountSats < 0) {
+        return { refused: "the decoded invoice carries no usable amount" };
+      }
+      if (facts.amountSats === 0) {
+        return { refused: "the invoice names no amount, and a send route needs one" };
+      }
+      return {
+        claimed: {
+          kind: "invoice",
+          bolt11: invoice,
+          paymentHash: facts.paymentHash,
+          amount: BigInt(facts.amountSats),
+          expiresAt: facts.expiresAt
+        }
+      };
+    }
+  }),
+  { target: import_sdk20.invoiceTarget }
+);
+
+// src/client/corridors/onchain.ts
+var import_sdk21 = require("@arkade-os/sdk");
+var btc3 = __toESM(require("@scure/btc-signer"), 1);
+var ONCHAIN_DRIVE = {
+  take: {
+    lockups: [
+      { covenant: "arkade_lockup", owner: "trader", deadline: "refund_locktime" },
+      { covenant: "onchain_htlc", owner: "solver", deadline: "htlc_refund_locktime" }
+    ],
+    actions: ["claimOnchain", "refundArkade"],
+    seams: ["indexer", "chain"]
+  }
+};
+var onchainCorridor = Object.assign(
+  (deps) => {
+    const l1 = l1NetworkFromArk(deps.networkName);
+    return {
+      corridor: "onchain",
+      deps,
+      drive: ONCHAIN_DRIVE,
+      matches(raw) {
+        const target = (0, import_sdk21.btcTarget)(raw);
+        if (target === void 0) return void 0;
+        try {
+          btc3.Address(L1_NETWORKS[l1]).decode(target);
+        } catch {
+          return { refused: `this is not a ${l1} address` };
+        }
+        return { claimed: { kind: "address", address: target } };
+      }
+    };
+  },
+  { target: import_sdk21.btcTarget }
+);
+
+// src/client/outcome.ts
+var CORRIDOR_PASS = {
+  lightning_send: LIGHTNING_DRIVE.take,
+  lightning_receive: LIGHTNING_DRIVE.give,
+  onchain_send: ONCHAIN_DRIVE.take
+};
+var LOCKUP_OWNER = {
+  lightning_send: CORRIDOR_PASS.lightning_send.lockups[0].owner,
+  lightning_receive: CORRIDOR_PASS.lightning_receive.lockups[0].owner,
+  onchain_send: CORRIDOR_PASS.onchain_send.lockups[0].owner
+};
+var at = (outcome) => () => outcome;
+var CORRIDOR_OUTCOME = {
+  trader: {
+    pending: at("funded"),
+    claimable: at("funded"),
+    claimed: at("funded"),
+    needs_counterparty: at("needs_recovery"),
+    settled: (kind) => kind === "onchain_send" ? "claimed" : "paid",
+    refunded: at("refunded"),
+    failed: at("failed")
+  },
+  solver: {
+    // The solver has funded nothing yet: the invoice is shown and unpaid,
+    // which is what makes this `open` where the trader's side is `funded`.
+    pending: at("open"),
+    claimable: at("funded"),
+    claimed: at("funded"),
+    needs_counterparty: at("needs_recovery"),
+    // The trader's OWN claim, matched by the hash and not by our txid — so
+    // a claim that lands without us still counts.
+    settled: at("claimed"),
+    // The one inversion this whole module exists for: every non-claim leaf
+    // of a receive covenant is the solver's, so a lockup spent by one is
+    // the trader's incoming payment never arriving.
+    refunded: at("lapsed"),
+    failed: at("failed")
+  }
+};
+var corridorOutcome = (kind, state) => CORRIDOR_OUTCOME[LOCKUP_OWNER[kind]][state](kind);
+var ACTIVITY_TOKEN = {
+  accepted: "pending",
+  funding: "pending",
+  funded: "pending",
+  open: "pending",
+  // The drive's in-flight states have no user-visible phase distinct from
+  // "pending"; `needs_recovery` is different in kind — the swap is BLOCKED —
+  // and collapsing it here is the same deliberate choice v1 made, which the
+  // opaque-token design permits because apps map tokens themselves.
+  needs_recovery: "pending",
+  refunding: "pending",
+  cancelling: "pending",
+  cancelled: "cancelled",
+  filled: "settled",
+  claimed: "settled",
+  paid: "settled",
+  refunded: "refunded",
+  lapsed: "lost",
+  failed: "failed"
+};
+
+// src/activity.ts
 var LABELS = {
   lightning_send: "Lightning send",
   lightning_receive: "Lightning receive",
   onchain_send: "Onchain send"
 };
-var OUTCOME = {
-  pending: "pending",
-  // `claimable` and `claimed` are both in-progress states with no
-  // user-visible phase distinct from "pending". `needs_counterparty` is
-  // different in kind — the swap is BLOCKED, not merely in flight, since no
-  // unilateral trader move exists (see `RfqSwapState`). Collapsing it into
-  // `pending` here is a deliberate choice the opaque-token design permits —
-  // apps map tokens themselves — but a future reader weighing a `"blocked"`
-  // or `"stuck"` token should know this was already considered.
-  claimable: "pending",
-  claimed: "pending",
-  needs_counterparty: "pending",
-  settled: "settled",
-  refunded: "refunded",
-  failed: "failed"
-};
+var outcomeToken = (kind, state) => ACTIVITY_TOKEN[corridorOutcome(kind, state)];
 function swapActivityResolver(deps) {
   let byTxid = /* @__PURE__ */ new Map();
   return {
@@ -4633,13 +5415,17 @@ function swapActivityResolver(deps) {
       const key = tx.key.arkTxid || tx.key.commitmentTxid || tx.key.boardingTxid;
       const swap = key ? byTxid.get(key) : void 0;
       if (!swap) return void 0;
-      const lostReceive = swap.kind === "lightning_receive" && swap.state === "refunded";
       return [
         {
           groupId: `swap:${swap.rfqId}`,
           label: LABELS[swap.kind],
           kind: "swap",
-          outcome: lostReceive ? "lost" : OUTCOME[swap.state],
+          // `"lost"` for a receive leg that ended `refunded` comes out
+          // of the translation rather than out of a branch here: that
+          // leg has no trader-side refund, every non-claim leaf of its
+          // covenant is the solver's, and the client's `lapsed` is
+          // that fact.
+          outcome: outcomeToken(swap.kind, swap.state),
           metadata: { rfqId: swap.rfqId, swapKind: swap.kind }
         }
       ];
@@ -4650,16 +5436,17 @@ 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) {
+async function activityInputOf(stored, indexer) {
+  const record = normalizeRfqSwapRecord(stored);
   const txids = /* @__PURE__ */ new Set();
-  if (record.fundingArkTxid) txids.add(record.fundingArkTxid);
-  if (record.refundArkTxid) txids.add(record.refundArkTxid);
+  if (record.fundingTxid) txids.add(record.fundingTxid);
+  if (record.refundTxid) txids.add(record.refundTxid);
   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)) {
+  for (const txid of record.lockupSpendTxids ?? []) txids.add(txid);
+  const spendUnknown = isRfqSwapTerminal(record.state) && !record.refundTxid && !record.lockupSpendTxids?.length;
+  if (indexer && (!record.fundingTxid || spendUnknown)) {
+    for (const txid of await lockupTxids(indexer, record, !record.fundingTxid)) {
       txids.add(txid);
     }
   }
@@ -4668,7 +5455,7 @@ async function activityInputOf(record, indexer) {
 async function lockupTxids(indexer, record, wantFunding) {
   let script;
   try {
-    script = import_base16.hex.encode(import_sdk16.ArkAddress.decode(record.lockupAddress).pkScript);
+    script = import_base16.hex.encode(import_sdk22.ArkAddress.decode(record.lockupAddress).pkScript);
   } catch {
     return [];
   }
@@ -4684,6 +5471,346 @@ async function lockupTxids(indexer, record, wantFunding) {
     return [];
   }
 }
+
+// src/swapClient.ts
+var import_base17 = require("@scure/base");
+var import_sdk23 = require("@arkade-os/sdk");
+var import_solver_discovery3 = require("@arkade-os/solver-discovery");
+var btc4 = __toESM(require("@scure/btc-signer"), 1);
+var sideCorridorsOf = (market) => {
+  const read = (value) => value === "lightning" || value === "onchain" ? value : "arkade";
+  const m = market;
+  return { base: read(m.base_corridor), quote: read(m.quote_corridor) };
+};
+var resolveKind = (market, give) => {
+  const corridors = sideCorridorsOf(market);
+  const giveCorridor = corridors[give];
+  const receiveCorridor = corridors[give === "base" ? "quote" : "base"];
+  if (giveCorridor === "arkade" && receiveCorridor === "arkade") return "spot";
+  if (receiveCorridor === "lightning") return "ln_send";
+  if (giveCorridor === "lightning") return "ln_receive";
+  if (receiveCorridor === "onchain") return "onchain_send";
+  return "onchain_receive";
+};
+var need = (value, what, leg) => {
+  if (value === void 0) throw new Error(`a ${leg} quote needs ${what}`);
+  return value;
+};
+var payoutScriptFor = (address, payoutPubkey, network) => address !== void 0 ? l1ScriptForAddress(address, network) : btc4.p2tr(payoutPubkey, void 0, L1_NETWORKS[network]).script;
+var corridorAmount = (input, leg) => {
+  const raw = need(input.amount, "an amount", leg);
+  const amountOn = need(input.amountOn, "amountOn ('give' or 'receive')", leg);
+  const amount = Number(raw);
+  if (!Number.isSafeInteger(amount) || amount <= 0) {
+    throw new Error(`a ${leg} amount must be a positive integer of sats, got ${String(raw)}`);
+  }
+  return { amount, amountSide: amountOn === "give" ? "from" : "to" };
+};
+function createSwapClient(deps) {
+  const { wallet, repository, transportFor } = deps;
+  const ark = deps.ark ?? walletOperator(wallet);
+  let reader;
+  const reading = () => reader ??= wallet.getArkadeReader();
+  const indexer = deps.indexer ?? {
+    getVtxos: async (opts) => {
+      if (!opts)
+        throw new Error("getVtxos on the swap indexer requires scripts or outpoints");
+      return (await reading()).getVtxos(opts);
+    },
+    getVirtualTxs: async (...args) => (await reading()).getVirtualTxs(...args)
+  };
+  const managerDeps = { indexer, chain: deps.chain, repository };
+  const manager = new RfqSwapManager(managerDeps);
+  const listeners = /* @__PURE__ */ new Set();
+  const notify2 = (swap) => {
+    for (const listener of listeners) {
+      try {
+        listener(swap);
+      } catch {
+      }
+    }
+  };
+  manager.onSwapUpdate((swap) => notify2({ family: "rfq", swap }));
+  const claimLockup = async (swap, vtxos, { partiallyClaimed }) => {
+    const record = await repository.getRfqSwap(swap.rfqId);
+    if (!record) throw new Error(`rfq swap ${swap.rfqId} has no stored record to claim from`);
+    const secret = rfqClaimSecretOf(record);
+    if (!secret) throw new Error(`rfq swap ${swap.rfqId} carries no claim secret`);
+    const script = swap.lockup?.script;
+    if (!script) throw new Error(`rfq swap ${swap.rfqId} carries no lockup covenant`);
+    const payoutAddress = rfqClaimDestinationOf(record);
+    if (!payoutAddress) {
+      throw new Error(`rfq swap ${swap.rfqId} carries no claim destination`);
+    }
+    return pushClaim(ark, {
+      contract: script,
+      receiver: await (0, import_sdk23.contractSigner)(wallet, secret.signingDescriptor),
+      preimage: await preimageForSwapRecord(wallet, secret),
+      vtxos,
+      destinationPkScript: import_sdk23.ArkAddress.decode(payoutAddress).pkScript,
+      expectedAmount: swap.expectedAmount,
+      partiallyClaimed
+    });
+  };
+  manager.setCallbacks({
+    refundArkade: arkadeRefunder({ operator: ark, indexer, wallet, repository }),
+    claimLockup,
+    ...deps.claimOnchain ? { claimOnchain: deps.claimOnchain } : {}
+  });
+  let watcher;
+  const quote = async (market, input) => {
+    const kind = resolveKind(market, input.give);
+    switch (kind) {
+      case "spot": {
+        const raw = need(input.amount, "an amount", kind);
+        const amountOn = need(input.amountOn, "amountOn ('give' or 'receive')", kind);
+        const plan = await (0, import_solver_discovery3.quoteOffer)(market, {
+          give: input.give,
+          ...amountOn === "give" ? { giveAmount: raw } : { wantAmount: raw },
+          fetchImpl: deps.discovery.fetchImpl
+        });
+        return { kind, market, plan };
+      }
+      case "ln_send": {
+        const invoice = need(input.invoice, "the invoice to pay", kind);
+        const request = await requestLightningSend(wallet, transportFor(market), {
+          invoice,
+          emulatorPubkey: deps.emulatorPubkey
+        });
+        return { kind, market, request };
+      }
+      case "ln_receive": {
+        const params = {
+          ...corridorAmount(input, kind),
+          covclaimdPubkey: need(deps.covclaimdPubkey, "deps.covclaimdPubkey", kind),
+          decodeInvoice: need(deps.decodeInvoice, "deps.decodeInvoice", kind),
+          maxPayAmount: input.maxPayAmount,
+          emulatorPubkey: deps.emulatorPubkey
+        };
+        const request = await requestLightningReceive(wallet, transportFor(market), params);
+        return { kind, market, request, invoice: request.invoice };
+      }
+      case "onchain_send": {
+        need(deps.chain, "deps.chain (L1 access)", kind);
+        const payoutPubkey = need(input.payoutPubkey, "a payoutPubkey", kind);
+        const params = {
+          ...corridorAmount(input, kind),
+          payoutPubkey,
+          preimage: input.preimage,
+          emulatorPubkey: deps.emulatorPubkey
+        };
+        const request = await requestOnchainSend(wallet, transportFor(market), params);
+        return {
+          kind,
+          market,
+          request,
+          payoutPkScript: payoutScriptFor(
+            input.payoutAddress,
+            payoutPubkey,
+            request.l1Network
+          )
+        };
+      }
+      case "onchain_receive":
+        throw new Error(
+          "onchain->arkade is not driven by RfqSwapManager yet; quote it directly with requestOnchainReceive"
+        );
+    }
+  };
+  const admit = async (swap, origin) => {
+    let announced = false;
+    const heard = manager.onSwapUpdate((updated) => {
+      if (updated.rfqId === swap.rfqId) announced = true;
+    });
+    try {
+      await manager.addSwap(swap, origin);
+    } finally {
+      heard();
+    }
+    const unified = { family: "rfq", swap };
+    if (!announced) notify2(unified);
+    return unified;
+  };
+  const fundPersisted = async (swap, origin, funding) => {
+    await repository.saveRfqSwap(createRfqSwapRecord(origin, swap));
+    return wallet.send({ address: funding.address, amount: funding.amount });
+  };
+  const accept = async (accepted) => {
+    const now = Math.floor(Date.now() / 1e3);
+    switch (accepted.kind) {
+      case "spot": {
+        const { plan } = accepted;
+        const depositIsBtc = plan.deposit.asset.id === BTC_ASSET_ID;
+        const offer = await createOffer(wallet, {
+          wantAmount: plan.receive.atomic,
+          ...plan.receive.asset.id === BTC_ASSET_ID ? { offerAsset: import_sdk23.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk23.asset.AssetId.fromString(plan.receive.asset.id) },
+          emulatorPubkey: deps.emulatorPubkey
+        });
+        const txid = await wallet.send({
+          address: offer.address,
+          // asset deposits ride the SDK's dust-sat carrier
+          amount: depositIsBtc ? Number(plan.deposit.atomic) : void 0,
+          assets: depositIsBtc ? void 0 : [{ assetId: plan.deposit.asset.id, amount: plan.deposit.atomic }],
+          extensions: [offer.extension]
+        });
+        const swap = {
+          id: txid,
+          fromAsset: plan.deposit.asset.id,
+          toAsset: plan.receive.asset.id,
+          fromAmount: plan.deposit.atomic.toString(),
+          toAmount: plan.receive.atomic.toString(),
+          swapAddress: offer.address,
+          swapPkScript: import_base17.hex.encode(offer.swapPkScript),
+          offerHex: offer.offerHex,
+          fundingTxid: txid,
+          status: "pending",
+          createdAt: Date.now()
+        };
+        await addAssetSwap(repository, swap);
+        const unified = { family: "offer", swap };
+        notify2(unified);
+        return unified;
+      }
+      case "ln_send": {
+        const { request } = accepted;
+        const swap = {
+          kind: "lightning_send",
+          rfqId: request.rfqId,
+          state: "pending",
+          lockupPkScript: request.swapPkScript,
+          lockup: { script: request.script, address: request.address },
+          // the trader's own decode, never the solver's echo
+          paymentHash: request.contractParams.paymentHash,
+          refundLocktime: request.contractParams.refundLocktime,
+          createdAt: now,
+          updatedAt: now
+        };
+        const origin = {
+          kind: "lightning_send",
+          lockupAddress: request.address,
+          profile: rfqSecretsProfile(request.secrets, swap.paymentHash),
+          amount: request.fundAmount
+        };
+        const txid = await fundPersisted(swap, origin, {
+          address: request.address,
+          amount: request.fundAmount
+        });
+        return admit(swap, { ...origin, fundingTxid: txid });
+      }
+      case "ln_receive": {
+        const { request } = accepted;
+        const paymentHash = import_base17.hex.encode(request.secrets.paymentHash);
+        const swap = {
+          kind: "lightning_receive",
+          rfqId: request.rfqId,
+          state: "pending",
+          lockupPkScript: request.swapPkScript,
+          lockup: { script: request.script, address: request.address },
+          paymentHash,
+          refundLocktime: request.contractParams.refundLocktime,
+          expectedAmount: request.expectedAmount,
+          createdAt: now,
+          updatedAt: now
+        };
+        return admit(swap, {
+          kind: "lightning_receive",
+          lockupAddress: request.address,
+          profile: {
+            ...rfqSecretsProfile(request.secrets, paymentHash),
+            expectedAmount: request.expectedAmount,
+            payoutAddress: request.payoutAddress
+          },
+          amount: request.expectedAmount
+        });
+      }
+      case "onchain_send": {
+        const { request } = accepted;
+        const paymentHash = import_base17.hex.encode(request.secrets.paymentHash);
+        const swap = {
+          kind: "onchain_send",
+          rfqId: request.rfqId,
+          state: "pending",
+          lockupPkScript: request.swapPkScript,
+          lockup: { script: request.script, address: request.address },
+          paymentHash,
+          refundLocktime: request.refundLocktime,
+          htlc: request.htlc,
+          minConfirmations: request.minConfirmations,
+          payoutPkScript: accepted.payoutPkScript,
+          createdAt: now,
+          updatedAt: now
+        };
+        const origin = {
+          kind: "onchain_send",
+          lockupAddress: request.address,
+          profile: {
+            ...rfqSecretsProfile(request.secrets, paymentHash),
+            ...onchainSendProfile({
+              ...request,
+              payoutPkScript: accepted.payoutPkScript
+            })
+          },
+          amount: request.fundAmount
+        };
+        const txid = await fundPersisted(swap, origin, {
+          address: request.address,
+          amount: request.fundAmount
+        });
+        return admit(swap, { ...origin, fundingTxid: txid });
+      }
+    }
+  };
+  return {
+    manager,
+    markets: (useCache) => discoverMarkets({ ...deps.discovery, repository, useCache }),
+    quote,
+    accept,
+    cancel: async (fundingTxid) => {
+      const swaps = await getAssetSwapsOrThrow(repository);
+      const swap = swaps.find((s) => s.id === fundingTxid);
+      if (!swap) throw new Error(`no offer swap with funding txid ${fundingTxid}`);
+      if (swap.status !== "pending") {
+        throw new Error(`offer swap ${fundingTxid} is ${swap.status}, not cancellable`);
+      }
+      await updateAssetSwap(repository, fundingTxid, { status: "cancelling" });
+      await cancelOffer(wallet, swap.offerHex, {
+        repository,
+        fundingTxid
+      });
+    },
+    // Both families, live AND terminal — the offer half reads the whole
+    // stored history, and the RFQ half is every swap the manager holds.
+    // Its history is what `start()` restored plus what this session
+    // accepted; records past `RFQ_SWAP_RETENTION_SECONDS` are pruned.
+    swaps: async () => {
+      const offers = await getAssetSwaps(repository);
+      const rfq = await manager.getAllSwaps();
+      return [
+        ...offers.map((swap) => ({ family: "offer", swap })),
+        ...rfq.map((swap) => ({ family: "rfq", swap }))
+      ];
+    },
+    onUpdate: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    start: async () => {
+      managerDeps.contracts ??= await wallet.getContractManager();
+      await manager.restoreFromRepository();
+      await manager.start();
+      watcher ??= await watchOfferSwaps({
+        wallet,
+        repository,
+        onUpdate: (swap) => notify2({ family: "offer", swap })
+      });
+    },
+    stop: async () => {
+      await manager.stop();
+      watcher?.stop();
+      watcher = void 0;
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ARKADE_ASSET,
@@ -4693,6 +5820,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   InMemoryAssetSwapRepository,
   IndexedDbAssetSwapRepository,
   LIGHTNING_BTC,
+  LIGHTNING_RAIL,
   LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR,
   LOCKTIME_THRESHOLD,
@@ -4703,6 +5831,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   MAX_MIN_CONFIRMATIONS,
   MIN_CLAIM_WINDOW_SECONDS,
   MIN_HEADROOM_SECONDS,
+  NoSpendableDepositError,
   OFFER_PACKET_TYPE,
   ONCHAIN_BTC,
   ONCHAIN_CLAIM_MARGIN_SECONDS,
@@ -4711,6 +5840,9 @@ async function lockupTxids(indexer, record, wantFunding) {
   ONCHAIN_RECEIVE_PAIR,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_SEND_PAIR,
+  ONCHAIN_SWAP_RAIL,
+  OfferCovenantMismatchError,
+  PAYMENT_STATUS,
   PreimageNotRecoverableError,
   QUOTE_OPTIONS,
   REFUND_MTP_LAG_SECONDS,
@@ -4727,6 +5859,8 @@ async function lockupTxids(indexer, record, wantFunding) {
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
+  SWAP_ROUTER_PRIORITY,
+  SwapPaymentFailedError,
   SwapRefusal,
   addAssetSwap,
   arkadeAssetLeg,
@@ -4741,6 +5875,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   buildHtlcRefund,
   cancelOffer,
   chainSourceFrom,
+  claimFeeSats,
   claimOnchainFill,
   claimReceiveLockup,
   classifyDepositSpend,
@@ -4748,6 +5883,8 @@ async function lockupTxids(indexer, record, wantFunding) {
   classifySpend,
   createOffer,
   createRfqSwapRecord,
+  createSwapClient,
+  createSwapPaymentRouter,
   decodeOffer,
   deriveLightningReceive,
   deriveOnchainReceive,
@@ -4762,28 +5899,35 @@ async function lockupTxids(indexer, record, wantFunding) {
   httpTransport,
   isRfqSwapTerminal,
   isRfqTerminal,
+  isTerminalStatus,
   l1ScriptForAddress,
+  lightningRail,
+  lightningReceiveContract,
   lightningReceiveRequest,
+  lightningSendContract,
   lightningSendRequest,
-  lightningSendVtxoScript,
   lockupContractParams,
   makeCachedFeedFetch,
   newPreimage,
   newRfqId,
   nextOnchainAction,
+  normalizeRfqSwapRecord,
+  offerContract,
   offerTermsFromQuote,
-  offerVtxoScript,
   onchainHtlcScript,
   onchainReceiveRequest,
   onchainSendProfile,
   onchainSendRequest,
+  onchainSwapRail,
   paymentHashOf,
+  paymentStatusOf,
   preimageForSwapRecord,
   pushClaim,
   pushRefundWithoutReceiver,
+  railAvailable,
   readLockupFate,
   rebuildRfqSwap,
-  receiveVtxoScript,
+  receiverExact,
   refundIfUnresolved,
   registerLockupContract,
   relayTransport,
@@ -4810,6 +5954,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   spendTxidsOf,
   spendUpdate,
   swapActivityResolver,
+  swapHandle,
   swapPrograms,
   swapSecretsToRecord,
   unilateralClaimDelay,