@arkade-os/swap 0.0.10 → 0.1.0-rc.0

package/dist/index.cjs

@@ -89,6 +89,7 @@ __export(index_exports, {
   classifySpend: () => classifySpend,
   createOffer: () => createOffer,
   createRfqSwapRecord: () => createRfqSwapRecord,
+  createSwapClient: () => createSwapClient,
   decodeOffer: () => decodeOffer,
   deriveLightningReceive: () => deriveLightningReceive,
   deriveOnchainReceive: () => deriveOnchainReceive,
@@ -103,16 +104,18 @@ __export(index_exports, {
   httpTransport: () => httpTransport,
   isRfqSwapTerminal: () => isRfqSwapTerminal,
   isRfqTerminal: () => isRfqTerminal,
+  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,
@@ -123,7 +126,6 @@ __export(index_exports, {
   pushRefundWithoutReceiver: () => pushRefundWithoutReceiver,
   readLockupFate: () => readLockupFate,
   rebuildRfqSwap: () => rebuildRfqSwap,
-  receiveVtxoScript: () => receiveVtxoScript,
   refundIfUnresolved: () => refundIfUnresolved,
   registerLockupContract: () => registerLockupContract,
   relayTransport: () => relayTransport,
@@ -411,32 +413,51 @@ var swapPrograms = {
   wantAsset: import_sdk2.arkade.parseArtifact(swap_want_asset_program_default),
   wantBtc: import_sdk2.arkade.parseArtifact(swap_want_btc_program_default)
 };
-function swapProgramBinding(offer, serverPubkey) {
+function withExitClosure(program, exit) {
+  if (!exit) return program;
+  return {
+    ...program,
+    // typed params are authoritative: an undeclared `$exitDelay` fails
+    // validateProgram instead of compiling against an unbound value
+    params: [...program.params ?? [], { name: "exitDelay", type: "int" }],
+    functions: {
+      ...program.functions,
+      exit: {
+        tapscript: { signers: ["$user"], csv: { type: exit.type, value: "$exitDelay" } }
+      }
+    }
+  };
+}
+function swapProgramBinding(offer, operatorPubkey) {
   if (offer.makerPkScript.length !== FIELDS.makerPkScript.width) {
     throw new Error("makerPkScript is not a 34-byte taproot scriptPubKey");
   }
   return {
-    program: offer.wantAsset ? swapPrograms.wantAsset : swapPrograms.wantBtc,
+    program: withExitClosure(
+      offer.wantAsset ? swapPrograms.wantAsset : swapPrograms.wantBtc,
+      offer.exitDelay
+    ),
     args: {
       makerWP: offer.makerPkScript.subarray(2),
       wantAmount: offer.wantAmount,
-      server: serverPubkey,
+      server: operatorPubkey,
       user: offer.makerPublicKey,
       // internal byte order
       ...offer.wantAsset && {
         wantAssetTxid: offer.wantAsset.txid.slice().reverse(),
         wantAssetGroupIndex: offer.wantAsset.groupIndex
-      }
+      },
+      ...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;
@@ -447,9 +468,27 @@ var FIELDS = {
   makerPkScript: { tag: 5, width: 34 },
   makerPublicKey: { tag: 7, width: 32 },
   emulatorPubkey: { tag: 8, width: 32 },
-  offerAsset: { tag: 11, width: void 0 }
+  ratioNum: { tag: 9, width: 8 },
+  ratioDen: { tag: 10, width: 8 },
+  offerAsset: { tag: 11, width: void 0 },
+  exitTimelock: { tag: 12, width: 9 }
 };
+var EXIT_TYPES = ["blocks", "seconds"];
 var NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
+function u64(name, value) {
+  if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
+    throw new Error(`${name} does not fit the offer wire format (u64)`);
+  }
+  const out = new Uint8Array(FIELDS.wantAmount.width);
+  new DataView(out.buffer).setBigUint64(0, value, false);
+  return out;
+}
+var readU64 = (value) => new DataView(value.buffer, value.byteOffset).getBigUint64(0, false);
+var setRatio = (name, value) => {
+  if (value === void 0 || value === BigInt(0)) return void 0;
+  if (value < BigInt(0)) throw new Error(`${name} does not fit the offer wire format (u64)`);
+  return value;
+};
 function tlv(type, value) {
   if (value.length > 65535) throw new Error("TLV value exceeds the u16 length field");
   return (0, import_utils.concatBytes)(Uint8Array.of(type, value.length >> 8 & 255, value.length & 255), value);
@@ -468,24 +507,45 @@ function encodeOffer(offer) {
       throw new Error(`${name} must be ${FIELDS[name].width} bytes`);
     }
   }
-  if (offer.wantAmount < BigInt(0) || offer.wantAmount >> BigInt(64) > BigInt(0)) {
-    throw new Error("wantAmount does not fit the offer wire format (u64)");
+  const ratioNum = setRatio("ratioNum", offer.ratioNum);
+  const ratioDen = setRatio("ratioDen", offer.ratioDen);
+  if (ratioNum === void 0 !== (ratioDen === void 0)) {
+    throw new Error("offer must carry both ratioNum and ratioDen, or neither");
   }
-  const amount = new Uint8Array(FIELDS.wantAmount.width);
-  new DataView(amount.buffer).setBigUint64(0, offer.wantAmount, false);
   const recs = [
     tlv(FIELDS.swapPkScript.tag, offer.swapPkScript),
-    tlv(FIELDS.wantAmount.tag, amount)
+    tlv(FIELDS.wantAmount.tag, u64("wantAmount", offer.wantAmount))
   ];
   if (offer.wantAsset) recs.push(tlv(FIELDS.wantAsset.tag, offer.wantAsset.serialize()));
+  if (ratioNum !== void 0) recs.push(tlv(FIELDS.ratioNum.tag, u64("ratioNum", ratioNum)));
+  if (ratioDen !== void 0) recs.push(tlv(FIELDS.ratioDen.tag, u64("ratioDen", ratioDen)));
   if (offer.offerAsset) recs.push(tlv(FIELDS.offerAsset.tag, offer.offerAsset.serialize()));
   recs.push(
     tlv(FIELDS.makerPkScript.tag, offer.makerPkScript),
     tlv(FIELDS.makerPublicKey.tag, offer.makerPublicKey),
     tlv(FIELDS.emulatorPubkey.tag, offer.emulatorPubkey)
   );
+  if (offer.exitDelay) recs.push(tlv(FIELDS.exitTimelock.tag, encodeExitDelay(offer.exitDelay)));
   return (0, import_utils.concatBytes)(...recs);
 }
+function encodeExitDelay(exit) {
+  return (0, import_utils.concatBytes)(
+    Uint8Array.of(EXIT_TYPES.indexOf(assertExitDelay(exit).type)),
+    u64("exitDelay", exit.value)
+  );
+}
+function assertExitDelay(exit) {
+  if (EXIT_TYPES.indexOf(exit.type) < 0) {
+    throw new Error(`unknown exitDelay locktime type: ${exit.type}`);
+  }
+  if (exit.value <= BigInt(0)) {
+    throw new Error("exitDelay must be a positive relative locktime");
+  }
+  if (exit.value >> BigInt(32) > BigInt(0)) {
+    throw new Error("exitDelay does not fit the locktime field (u32)");
+  }
+  return exit;
+}
 function decodeOffer(data) {
   const fields = {};
   let off = 0;
@@ -505,40 +565,70 @@ function decodeOffer(data) {
   for (const name of ["wantAsset", "offerAsset"]) {
     if (fields[name]?.length === 0) throw new Error(`missing/invalid ${name}`);
   }
-  const need = (name) => {
+  for (const [name, value] of Object.entries(fields)) {
+    const width = FIELDS[name].width;
+    if (width !== void 0 && value.length !== width) {
+      throw new Error(`missing/invalid ${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");
   }
+  const readRatio = (name) => {
+    const raw = fields[name];
+    if (!raw) return void 0;
+    const value = readU64(raw);
+    if (value === BigInt(0)) throw new Error(`missing/invalid ${name}`);
+    return value;
+  };
+  const ratioNum = readRatio("ratioNum");
+  const ratioDen = readRatio("ratioDen");
+  if (ratioNum === void 0 !== (ratioDen === void 0)) {
+    throw new Error("offer must carry both ratioNum and ratioDen, or neither");
+  }
   return {
-    swapPkScript: need("swapPkScript"),
-    wantAmount: new DataView(amount.buffer, amount.byteOffset).getBigUint64(0, false),
+    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) }
   };
 }
+function decodeExitDelay(value) {
+  const type = EXIT_TYPES[value[0]];
+  if (!type) throw new Error(`unknown exitDelay locktime type: 0x${value[0].toString(16)}`);
+  return { type, value: readU64(value.subarray(1)) };
+}
 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);
@@ -551,17 +641,29 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
   });
   await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript));
 }
-async function createOffer(wallet, arkServerUrl, params) {
+function serverExitDelay(delay) {
+  if (typeof delay !== "bigint" || delay <= BigInt(0)) {
+    throw new Error(
+      "the server reports no usable unilateralExitDelay; pass `exitDelay` to set the offer's exit closure explicitly, or `noExit: true` to publish without one"
+    );
+  }
+  return assertExitDelay({ value: delay, type: delay < BigInt(512) ? "blocks" : "seconds" });
+}
+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))
   );
@@ -571,35 +673,39 @@ async function createOffer(wallet, arkServerUrl, params) {
     offerAsset: params.offerAsset,
     makerPkScript: import_sdk2.ArkAddress.decode(makerAddress).pkScript,
     makerPublicKey,
-    emulatorPubkey: emuKey
+    emulatorPubkey: emuKey,
+    // checked HERE, before the covenant is derived and registered below:
+    // deferring it to `encodeOffer` leaves a registered contract behind for
+    // 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 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
@@ -614,7 +720,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   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"
+      "rebuilt covenant does not match the offer's swapPkScript \u2014 the operator signing key has likely rotated since funding; pass swapAddress (the funded address) to pin the original key"
     );
   }
   const contract = new import_sdk2.arkade.ArkadeContract(client, program, args, keys);
@@ -1278,7 +1384,7 @@ var LightningReceiveCorridor = {
     const receive = swap;
     return {
       expectedAmount: receive.expectedAmount,
-      ...receive.claimArkTxid ? { claimArkTxid: receive.claimArkTxid } : {}
+      ...receive.claimTxid ? { claimTxid: receive.claimTxid } : {}
     };
   },
   hydrate(profile) {
@@ -1288,13 +1394,13 @@ 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] : []
+  activityTxids: (profile) => profile.claimTxid ? [profile.claimTxid] : []
 };
 function onchainSendProfile(result) {
   return {
@@ -1378,13 +1484,32 @@ 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.blockedReason ? { blockedReason: swap.blockedReason } : {}
 });
@@ -1415,27 +1540,29 @@ 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,
     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) {
@@ -1449,27 +1576,28 @@ 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.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) {
@@ -1506,13 +1634,15 @@ 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 = {
-      cancel: script.functionByName("cancel")?.leafScript,
+      // both routes that hand the deposit back; `exit` is absent on an
+      // offer that carries no exit closure, and drops out here
+      returned: ["cancel", "exit"].map((name) => script.functionByName(name)?.leafScript).filter((leaf) => leaf !== void 0),
       fulfill: script.functionByName("fulfill")?.leafScript
     };
   } catch {
@@ -1524,22 +1654,22 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
     if (import_base6.hex.encode(input.txid) !== deposit.txid) continue;
     for (const leaf of input.tapLeafScript ?? []) {
       const spent = import_base6.hex.encode((0, import_sdk6.scriptFromTapLeafScript)(leaf));
-      if (leaves.cancel && spent === import_base6.hex.encode(leaves.cancel)) return "cancelled";
+      if (leaves.returned.some((back) => spent === import_base6.hex.encode(back))) return "cancelled";
       if (leaves.fulfill && spent === import_base6.hex.encode(leaves.fulfill)) return "fulfilled";
     }
   }
   return "indeterminate";
 }
 var spendTxidsOf = (vtxo) => [vtxo.spentBy, vtxo.arkTxId].filter((id) => Boolean(id));
-function classifyDepositSpend(offer, serverPubkey, spendTxs, deposit) {
+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]));
@@ -1608,7 +1738,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
       });
@@ -1625,7 +1755,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: "",
@@ -1660,13 +1790,15 @@ function spendUpdate(swap, spend) {
 }
 async function watchOfferSwaps({
   wallet,
-  arkServerUrl,
   repository,
   onUpdate
 }) {
-  const manager = await wallet.getContractManager();
-  const serverPubkey = import_sdk7.ArkAddress.decode(await wallet.getAddress()).serverPubKey;
-  const indexer = new import_sdk7.RestIndexerProvider(arkServerUrl);
+  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(() => {
@@ -1680,7 +1812,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 }
       );
@@ -1834,11 +1966,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;
   }
@@ -1918,8 +2053,22 @@ var assertPairLength = (pair) => {
 };
 var verifyLockupAddress = (quote, derivedAddress) => {
   const quoted = quote.profile?.lockup_address;
-  if (derivedAddress !== quoted) throw new AddressMismatch(derivedAddress, quoted);
-  return derivedAddress;
+  const candidates = Array.isArray(derivedAddress) ? derivedAddress : [derivedAddress];
+  const matched = candidates.find((address) => address === quoted);
+  if (matched === void 0) throw new AddressMismatch(candidates, quoted);
+  return matched;
+};
+var LOCKUP_SHAPE_VARIANTS = [void 0, "preTimelockedRefund"];
+var matchQuotedLockup = (quote, hrp, serverPubkey, build) => {
+  const candidates = LOCKUP_SHAPE_VARIANTS.map((legacy) => {
+    const script = build(legacy);
+    return { script, address: script.address(hrp, serverPubkey).encode(), legacy };
+  });
+  const matchedAddress = verifyLockupAddress(
+    quote,
+    candidates.map((candidate) => candidate.address)
+  );
+  return candidates.find((candidate) => candidate.address === matchedAddress);
 };
 var assertFundable = (input) => {
   const fail = (reason, message) => {
@@ -2090,22 +2239,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)
@@ -2113,7 +2262,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),
@@ -2121,22 +2270,20 @@ function lightningSendVtxoScript(params) {
     unilateralRefundWithoutReceiverDelay: seconds(
       unilateralRefundWithoutReceiverDelay(params.claimDelay)
     ),
-    nonInteractiveClaim: {
+    nonInteractiveParameters: {
       receiverPkScript: params.receiverPkScript,
-      emulatorPubkey: params.emulatorPubkey
-    },
-    nonInteractiveRefund: {
       senderPkScript: params.refundPkScript,
-      emulatorPubkey: params.emulatorPubkey
+      emulatorPubkey: params.emulatorPubkey,
+      ...params.legacy !== void 0 && { legacy: params.legacy }
     }
   });
 }
-async function requestLightningSend(wallet, arkServerUrl, transport, params) {
+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 new import_sdk9.RestArkProvider(arkServerUrl).getInfo();
+  const info = await wallet.getArkadeInfo({ requireLive: true });
   const quote = await transport.requestQuote(
     lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
   );
@@ -2157,12 +2304,12 @@ 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 = {
+  const operatorPubkey = (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key");
+  const network = (0, import_sdk9.networkFromArkadeInfo)(info);
+  const contractParams = {
     solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
-    serverPubkey,
+    operatorPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
     emulatorPubkey: (0, import_sdk9.toXOnly)(
@@ -2173,9 +2320,18 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
     refundPkScript: secrets.pkScript
   };
-  const script = lightningSendVtxoScript(treeParams);
-  const address = script.address(network.hrp, serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  const matched = matchQuotedLockup(
+    quote,
+    network.hrp,
+    operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
+  const script = matched.script;
+  const address = matched.address;
+  const matchedContractParams = {
+    ...contractParams,
+    ...matched.legacy !== void 0 && { legacy: matched.legacy }
+  };
   assertFundable({
     quote,
     invoiceExpiresAt: params.invoice.expiresAt,
@@ -2194,7 +2350,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     refundAddress,
     senderPubkey,
     secrets,
-    treeParams
+    contractParams: matchedContractParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -2259,19 +2415,23 @@ 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 script = lightningSendVtxoScript({
+  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,
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
     refundPkScript: import_sdk9.ArkAddress.decode(input.refundAddress).pkScript
-  });
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  };
+  const { script, address } = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningSendContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
@@ -2292,7 +2452,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) {
@@ -2303,7 +2463,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(
@@ -2317,12 +2477,12 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
       amountSide: params.amountSide
     })
   );
-  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"
@@ -2359,6 +2519,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     htlcParams: derived.htlcParams,
     l1Network: derived.l1Network,
     minConfirmations: derived.minConfirmations,
+    refundLocktime: derived.refundLocktime,
     senderPubkey,
     secrets
   };
@@ -2430,7 +2591,7 @@ var assertReceivable = (input) => {
     );
   }
 };
-function receiveVtxoScript(params) {
+function lightningReceiveContract(params) {
   const seconds = (value) => ({
     type: "seconds",
     value: BigInt(value)
@@ -2438,7 +2599,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),
@@ -2446,13 +2607,11 @@ function receiveVtxoScript(params) {
     unilateralRefundWithoutReceiverDelay: seconds(
       unilateralRefundWithoutReceiverDelay(params.claimDelay)
     ),
-    nonInteractiveClaim: {
+    nonInteractiveParameters: {
       receiverPkScript: params.payoutPkScript,
-      emulatorPubkey: params.emulatorPubkey
-    },
-    nonInteractiveRefund: {
       senderPkScript: params.solverRefundPkScript,
-      emulatorPubkey: params.emulatorPubkey
+      emulatorPubkey: params.emulatorPubkey,
+      ...params.legacy !== void 0 && { legacy: params.legacy }
     }
   });
 }
@@ -2465,10 +2624,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,
@@ -2476,12 +2635,25 @@ function deriveLightningReceive(input) {
     payoutPubkey: input.payoutPubkey,
     payoutPkScript: import_sdk9.ArkAddress.decode(input.payoutAddress).pkScript
   };
-  const script = receiveVtxoScript(treeParams);
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
-  return { address, swapPkScript: script.pkScript, script, invoice, refundLocktime, treeParams };
+  const matched = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({ ...contractParams, ...legacy !== void 0 && { legacy } })
+  );
+  return {
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    invoice,
+    refundLocktime,
+    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) {
@@ -2493,7 +2665,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({
@@ -2512,13 +2684,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"
@@ -2552,7 +2724,7 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     payoutAddress,
     payoutPubkey,
     secrets,
-    treeParams: derived.treeParams
+    contractParams: derived.contractParams
   };
 }
 function deriveOnchainReceive(input) {
@@ -2567,19 +2739,26 @@ 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 script = receiveVtxoScript({
+  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,
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
     payoutPkScript: import_sdk9.ArkAddress.decode(input.payoutAddress).pkScript
-  });
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  };
+  const { script, address } = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.operatorPubkey,
+    (legacy) => lightningReceiveContract({
+      ...contractParams,
+      ...legacy !== void 0 && { legacy }
+    })
+  );
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
@@ -2600,7 +2779,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) {
@@ -2612,7 +2791,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({
@@ -2632,14 +2811,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"
@@ -2717,11 +2896,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) {
@@ -2782,7 +2960,7 @@ async function readLockupFate(indexer, input) {
     if (vtxo.spentBy)
       spentBy.set(vtxo.spentBy, {
         checkpointTxid: vtxo.spentBy,
-        arkTxid: vtxo.arkTxId
+        txid: vtxo.arkTxId
       });
     else everySpendNamed = false;
   }
@@ -2811,32 +2989,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.nonInteractiveRefund?.senderPkScript;
+  const refundPkScript = input.refundPkScript ?? input.contract.options.nonInteractiveParameters?.senderPkScript;
   if (!refundPkScript) {
     throw new Error(
-      "no refund destination: the contract carries no nonInteractiveRefund leaf, so pass refundPkScript explicitly"
+      "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_sdk11.CSVMultisigTapscript.decode(import_base11.hex.decode(info.checkpointTapscript));
+    operatorUnrollScript = import_sdk11.CSVMultisigTapscript.decode(import_base11.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_sdk11.buildOffchainTx)(
+  const { arkTx: tx, checkpoints } = (0, import_sdk11.buildOffchainTx)(
     input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -2845,14 +3023,14 @@ 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_base11.base64.encode(signedArkTx.toPSBT()),
+  const signedTx = await input.sender.sign(tx);
+  const submitted = await operator.submitTx(
+    import_base11.base64.encode(signedTx.toPSBT()),
     checkpoints.map((c) => import_base11.base64.encode(c.toPSBT()))
   );
-  (0, import_sdk11.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
+  (0, import_sdk11.assertSubmittedArkTxid)(submitted, signedTx, "refundWithoutReceiver");
   const matched = (0, import_sdk11.matchServerCheckpoints)(
     submitted.signedCheckpointTxs,
     checkpoints,
@@ -2863,11 +3041,11 @@ async function pushRefundWithoutReceiver(ark, input) {
       async ({ server }) => import_base11.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;
@@ -2875,11 +3053,26 @@ async function refundIfUnresolved(transport, ark, indexer, input) {
     const status = await transport.status(input.rfqId);
     if (status && isResolved(status.state)) return { outcome: "resolved", status };
     if (now() >= input.refundLocktime) {
-      const vtxos = await findLockupVtxos(indexer, input.script.pkScript);
+      let fate = { fate: "unknown" };
+      try {
+        fate = await readLockupFate(indexer, {
+          swapPkScript: input.contract.pkScript,
+          paymentHash: input.paymentHash
+        });
+      } catch {
+      }
+      if (fate.fate === "exited") {
+        return {
+          outcome: "exited",
+          outpoints: fate.outpoints.map((o) => `${o.txid}:${o.vout}`),
+          status
+        };
+      }
+      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
@@ -2922,13 +3115,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);
@@ -2939,22 +3132,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_base12.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base12.hex.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
-  const info = await ark.getInfo();
-  let serverUnrollScript;
+  const info = await operator.getInfo();
+  let operatorUnrollScript;
   try {
-    serverUnrollScript = import_sdk12.CSVMultisigTapscript.decode(import_base12.hex.decode(info.checkpointTapscript));
+    operatorUnrollScript = import_sdk12.CSVMultisigTapscript.decode(import_base12.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_sdk12.signAndSubmitOffchainTx)({
+  const leaf = input.contract.claim();
+  const tapTree = input.contract.encode();
+  const txid = await (0, import_sdk12.signAndSubmitOffchainTx)({
     identity: (0, import_sdk12.claimWithPreimageIdentity)(input.receiver, input.preimage),
-    provider: ark,
+    provider: operator,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -2965,10 +3158,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;
@@ -2983,13 +3176,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,
@@ -3040,8 +3233,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`
       );
@@ -3056,7 +3249,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 });
   };
 }
 
@@ -3452,6 +3645,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);
   }
@@ -3730,14 +3936,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) {
+    if (failure && !swap.claimTxid) {
       return this.fail(swap, new Error(failure));
     }
     this.setState(swap, "refunded");
@@ -3752,7 +3958,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;
     }
@@ -3780,10 +3986,10 @@ var RfqSwapManager = class {
     this.setState(swap, "claimable");
     if (!this.config.enableAutoActions) return;
     try {
-      const { arkTxid } = await this.callbacks.claimLockup(swap, vtxos, { partiallyClaimed });
+      const { txid } = await this.callbacks.claimLockup(swap, vtxos, { partiallyClaimed });
       this.lastClaimError.delete(swap.rfqId);
       this.rememberClaimed(swap.rfqId, vtxos);
-      swap.claimArkTxid = arkTxid;
+      swap.claimTxid = txid;
       this.touch(swap);
       this.setState(swap, "claimed");
       this.emitAction(swap, "claimLockup");
@@ -3875,7 +4081,7 @@ var RfqSwapManager = class {
     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");
@@ -3948,7 +4154,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.
@@ -3958,9 +4164,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) {
@@ -4041,10 +4247,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;
@@ -4080,7 +4285,7 @@ var traderClaimTxid = (swap) => {
     case "onchain_send":
       return swap.claimTxid;
     case "lightning_receive":
-      return swap.claimArkTxid;
+      return swap.claimTxid;
     default:
       return void 0;
   }
@@ -4090,7 +4295,7 @@ 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);
@@ -4155,16 +4360,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);
     }
   }
@@ -4189,6 +4395,334 @@ async function lockupTxids(indexer, record, wantFunding) {
     return [];
   }
 }
+
+// src/swapClient.ts
+var import_base15 = require("@scure/base");
+var import_sdk15 = require("@arkade-os/sdk");
+var import_solver_discovery2 = require("@arkade-os/solver-discovery");
+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 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;
+  let broadcaster;
+  const broadcasting = () => broadcaster ??= wallet.getArkadeBroadcaster();
+  const ark = deps.ark ?? {
+    getInfo: () => wallet.getArkadeInfo({ requireLive: true }),
+    submitTx: async (...args) => (await broadcasting()).submitTx(...args),
+    finalizeTx: async (...args) => (await broadcasting()).finalizeTx(...args)
+  };
+  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 = record.profile.payoutAddress;
+    if (!payoutAddress) throw new Error(`rfq swap ${swap.rfqId} carries no payoutAddress`);
+    return pushClaim(ark, {
+      contract: script,
+      receiver: await (0, import_sdk15.contractSigner)(wallet, secret.signingDescriptor),
+      preimage: await preimageForSwapRecord(wallet, secret),
+      vtxos,
+      destinationPkScript: import_sdk15.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_discovery2.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 params = {
+          ...corridorAmount(input, kind),
+          payoutPubkey: need(input.payoutPubkey, "a payoutPubkey", kind),
+          preimage: input.preimage,
+          emulatorPubkey: deps.emulatorPubkey
+        };
+        const request = await requestOnchainSend(wallet, transportFor(market), params);
+        return { kind, market, request };
+      }
+      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_sdk15.asset.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: import_sdk15.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_base15.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_base15.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_base15.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,
+          createdAt: now,
+          updatedAt: now
+        };
+        const origin = {
+          kind: "onchain_send",
+          lockupAddress: request.address,
+          profile: {
+            ...rfqSecretsProfile(request.secrets, paymentHash),
+            ...onchainSendProfile(request)
+          },
+          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,
@@ -4250,6 +4784,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   classifySpend,
   createOffer,
   createRfqSwapRecord,
+  createSwapClient,
   decodeOffer,
   deriveLightningReceive,
   deriveOnchainReceive,
@@ -4264,16 +4799,18 @@ async function lockupTxids(indexer, record, wantFunding) {
   httpTransport,
   isRfqSwapTerminal,
   isRfqTerminal,
+  lightningReceiveContract,
   lightningReceiveRequest,
+  lightningSendContract,
   lightningSendRequest,
-  lightningSendVtxoScript,
   lockupContractParams,
   makeCachedFeedFetch,
   newPreimage,
   newRfqId,
   nextOnchainAction,
+  normalizeRfqSwapRecord,
+  offerContract,
   offerTermsFromQuote,
-  offerVtxoScript,
   onchainHtlcScript,
   onchainReceiveRequest,
   onchainSendProfile,
@@ -4284,7 +4821,6 @@ async function lockupTxids(indexer, record, wantFunding) {
   pushRefundWithoutReceiver,
   readLockupFate,
   rebuildRfqSwap,
-  receiveVtxoScript,
   refundIfUnresolved,
   registerLockupContract,
   relayTransport,