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

package/dist/index.js

@@ -38,9 +38,10 @@ import {
   deriveOnchainSend,
   extractPreimage,
   httpTransport,
+  lightningReceiveContract,
   lightningReceiveRequest,
+  lightningSendContract,
   lightningSendRequest,
-  lightningSendVtxoScript,
   lockupContractParams,
   newPreimage,
   newRfqId,
@@ -49,7 +50,6 @@ import {
   onchainReceiveRequest,
   onchainSendRequest,
   paymentHashOf,
-  receiveVtxoScript,
   registerLockupContract,
   relayTransport,
   requestLightningReceive,
@@ -63,7 +63,7 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-5NPYNQ5V.js";
+} from "./chunk-AM3NNUMR.js";
 import {
   InMemoryAssetSwapRepository,
   marketsCacheKey
@@ -74,11 +74,9 @@ import { hex as hex2 } from "@scure/base";
 import { concatBytes } from "@scure/btc-signer/utils.js";
 import {
   ArkAddress,
-  RestArkProvider,
-  RestIndexerProvider,
   arkade,
   asset,
-  getNetwork,
+  networkFromArkadeInfo,
   resolveEmulatorPubkey,
   toXOnlySignerHex
 } from "@arkade-os/sdk";
@@ -329,32 +327,51 @@ var swapPrograms = {
   wantAsset: arkade.parseArtifact(swap_want_asset_program_default),
   wantBtc: 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 arkade.ArkadeProgramScript(program, args, keys);
 }
 var OFFER_PACKET_TYPE = 3;
@@ -365,9 +382,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 concatBytes(Uint8Array.of(type, value.length >> 8 & 255, value.length & 255), value);
@@ -386,24 +421,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 concatBytes(...recs);
 }
+function encodeExitDelay(exit) {
+  return 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;
@@ -423,40 +479,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: asset.AssetId.fromBytes(fields.wantAsset) },
     ...fields.offerAsset && { offerAsset: 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 arkade.Arkade.connect({
-    arkade: new RestArkProvider(arkServerUrl),
-    indexer: new 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: getNetwork(network),
+    network: networkFromArkadeInfo(info),
     contractManager
   });
   const contract = new arkade.ArkadeContract(client, program, args, keys);
@@ -469,17 +555,29 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
   });
   await promoteOfferContract(contractManager, hex2.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 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 = hex2.decode(toXOnlySignerHex(info.signerPubkey));
-  const network = getNetwork(info.network);
+  const operatorPubKey = hex2.decode(toXOnlySignerHex(info.signerPubkey));
+  const network = networkFromArkadeInfo(info);
   const emuKey = hex2.decode(
     toXOnlySignerHex(resolveEmulatorPubkey(network, params.emulatorPubkey))
   );
@@ -489,35 +587,39 @@ async function createOffer(wallet, arkServerUrl, params) {
     offerAsset: params.offerAsset,
     makerPkScript: 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: hex2.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(hex2.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 arkade.Arkade.connect({
-    arkade: new RestArkProvider(arkServerUrl),
-    indexer: new 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
@@ -532,7 +634,7 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
   const rebuilt = new arkade.ArkadeProgramScript(program, args, keys);
   if (hex2.encode(rebuilt.pkScript) !== hex2.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 arkade.ArkadeContract(client, program, args, keys);
@@ -940,7 +1042,7 @@ var LightningReceiveCorridor = {
     const receive = swap;
     return {
       expectedAmount: receive.expectedAmount,
-      ...receive.claimArkTxid ? { claimArkTxid: receive.claimArkTxid } : {}
+      ...receive.claimTxid ? { claimTxid: receive.claimTxid } : {}
     };
   },
   hydrate(profile) {
@@ -950,13 +1052,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 {
@@ -1040,13 +1142,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 } : {}
 });
@@ -1077,27 +1198,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) {
@@ -1111,27 +1234,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) {
@@ -1172,13 +1296,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 (hex5.encode(script.pkScript) !== hex5.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 {
@@ -1190,22 +1316,22 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
     if (hex5.encode(input.txid) !== deposit.txid) continue;
     for (const leaf of input.tapLeafScript ?? []) {
       const spent = hex5.encode(scriptFromTapLeafScript(leaf));
-      if (leaves.cancel && spent === hex5.encode(leaves.cancel)) return "cancelled";
+      if (leaves.returned.some((back) => spent === hex5.encode(back))) return "cancelled";
       if (leaves.fulfill && spent === hex5.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]));
@@ -1274,7 +1400,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
       });
@@ -1291,7 +1417,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: "",
@@ -1313,7 +1439,6 @@ async function restoreAssetSwaps(indexer, txs, existingIds, opts) {
 import { base64 as base642, hex as hex6 } from "@scure/base";
 import {
   ArkAddress as ArkAddress3,
-  RestIndexerProvider as RestIndexerProvider3,
   Transaction as Transaction2
 } from "@arkade-os/sdk";
 var TERMINAL = ["fulfilled", "cancelled", "recoverable"];
@@ -1330,13 +1455,15 @@ function spendUpdate(swap, spend) {
 }
 async function watchOfferSwaps({
   wallet,
-  arkServerUrl,
   repository,
   onUpdate
 }) {
-  const manager = await wallet.getContractManager();
-  const serverPubkey = ArkAddress3.decode(await wallet.getAddress()).serverPubKey;
-  const indexer = new RestIndexerProvider3(arkServerUrl);
+  const [manager, address, indexer] = await Promise.all([
+    wallet.getContractManager(),
+    wallet.getAddress(),
+    wallet.getArkadeReader()
+  ]);
+  const operatorPubkey = ArkAddress3.decode(address).serverPubKey;
   let queue = Promise.resolve();
   const enqueue = (task) => {
     queue = queue.then(task).catch(() => {
@@ -1350,7 +1477,7 @@ async function watchOfferSwaps({
       const { txs } = await indexer.getVirtualTxs(candidates);
       return classifyDepositSpend(
         decodeOffer(hex6.decode(swap.offerHex)),
-        serverPubkey,
+        operatorPubkey,
         txs.map((psbt) => Transaction2.fromPSBT(base642.decode(psbt))),
         { txid: vtxo.txid, vout: vtxo.vout }
       );
@@ -1445,11 +1572,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) {
@@ -1510,7 +1636,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;
   }
@@ -1539,32 +1665,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 = CSVMultisigTapscript.decode(hex7.decode(info.checkpointTapscript));
+    operatorUnrollScript = CSVMultisigTapscript.decode(hex7.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 } = buildOffchainTx(
+  const { arkTx: tx, checkpoints } = buildOffchainTx(
     input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -1573,14 +1699,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(
-    base643.encode(signedArkTx.toPSBT()),
+  const signedTx = await input.sender.sign(tx);
+  const submitted = await operator.submitTx(
+    base643.encode(signedTx.toPSBT()),
     checkpoints.map((c) => base643.encode(c.toPSBT()))
   );
-  assertSubmittedArkTxid(submitted, signedArkTx, "refundWithoutReceiver");
+  assertSubmittedArkTxid(submitted, signedTx, "refundWithoutReceiver");
   const matched = matchServerCheckpoints(
     submitted.signedCheckpointTxs,
     checkpoints,
@@ -1591,11 +1717,11 @@ async function pushRefundWithoutReceiver(ark, input) {
       async ({ server }) => base643.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;
@@ -1603,11 +1729,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
@@ -1650,13 +1791,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);
@@ -1667,22 +1808,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 (hex8.encode(ripemd160(sha2563(input.preimage))) !== hex8.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 = CSVMultisigTapscript2.decode(hex8.decode(info.checkpointTapscript));
+    operatorUnrollScript = CSVMultisigTapscript2.decode(hex8.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 signAndSubmitOffchainTx({
+  const leaf = input.contract.claim();
+  const tapTree = input.contract.encode();
+  const txid = await signAndSubmitOffchainTx({
     identity: claimWithPreimageIdentity(input.receiver, input.preimage),
-    provider: ark,
+    provider: operator,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -1693,10 +1834,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;
@@ -1711,13 +1852,13 @@ async function awaitLockupFunding(indexer, swapPkScript, options = {}) {
     await sleep2(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,
@@ -1772,8 +1913,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`
       );
@@ -1788,7 +1929,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 });
   };
 }
 
@@ -2184,6 +2325,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);
   }
@@ -2462,14 +2616,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");
@@ -2484,7 +2638,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;
     }
@@ -2512,10 +2666,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");
@@ -2607,7 +2761,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");
@@ -2680,7 +2834,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.
@@ -2690,9 +2844,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) {
@@ -2773,10 +2927,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;
@@ -2812,7 +2965,7 @@ var traderClaimTxid = (swap) => {
     case "onchain_send":
       return swap.claimTxid;
     case "lightning_receive":
-      return swap.claimArkTxid;
+      return swap.claimTxid;
     default:
       return void 0;
   }
@@ -2822,7 +2975,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);
@@ -2889,16 +3042,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);
     }
   }
@@ -2923,6 +3077,334 @@ async function lockupTxids(indexer, record, wantFunding) {
     return [];
   }
 }
+
+// src/swapClient.ts
+import { hex as hex11 } from "@scure/base";
+import { ArkAddress as ArkAddress5, asset as asset2, contractSigner as contractSigner2 } from "@arkade-os/sdk";
+import { quoteOffer } from "@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 contractSigner2(wallet, secret.signingDescriptor),
+      preimage: await preimageForSwapRecord(wallet, secret),
+      vtxos,
+      destinationPkScript: ArkAddress5.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 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: asset2.AssetId.fromString(plan.deposit.asset.id) } : { wantAsset: asset2.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: hex11.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 = hex11.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 = hex11.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;
+    }
+  };
+}
 export {
   ARKADE_ASSET,
   ARKADE_BTC,
@@ -2983,6 +3465,7 @@ export {
   classifySpend,
   createOffer,
   createRfqSwapRecord,
+  createSwapClient,
   decodeOffer,
   deriveLightningReceive,
   deriveOnchainReceive,
@@ -2997,16 +3480,18 @@ export {
   httpTransport,
   isRfqSwapTerminal,
   isRfqTerminal,
+  lightningReceiveContract,
   lightningReceiveRequest,
+  lightningSendContract,
   lightningSendRequest,
-  lightningSendVtxoScript,
   lockupContractParams,
   makeCachedFeedFetch,
   newPreimage,
   newRfqId,
   nextOnchainAction,
+  normalizeRfqSwapRecord,
+  offerContract,
   offerTermsFromQuote,
-  offerVtxoScript,
   onchainHtlcScript,
   onchainReceiveRequest,
   onchainSendProfile,
@@ -3017,7 +3502,6 @@ export {
   pushRefundWithoutReceiver,
   readLockupFate,
   rebuildRfqSwap,
-  receiveVtxoScript,
   refundIfUnresolved,
   registerLockupContract,
   relayTransport,