@arkade-os/swap 0.0.10 → 0.0.11

package/README.md

@@ -759,6 +759,23 @@ through their stored `preimageHex` or their HD descriptor, and `DB_VERSION` is u
 
 Notes from before 0.0.1, kept for consumers who tracked the branch.
 
+- **`refundIfUnresolved` reports an exited lockup, and its input gained `paymentHash`.**
+  `RefundOutcome` has a new `{ outcome: "exited"; outpoints; status }` variant: a lockup whose
+  outputs were unilaterally exited lives onchain under the VHTLC script, where no offchain refund
+  reaches it. It used to come back as `nothing_to_refund`, which reads as "already resolved" over
+  money still sitting at the script — the swept case gets `needs_recovery` for the same reason, and
+  this is deliberately **not** that variant: recovery into a fresh batch is a spend no batch can
+  make for an onchain output. Complete the unroll and spend the outputs onchain instead.
+
+  Two required changes for direct callers. The input gains **`paymentHash`** (`sha256(P)` hex — the
+  quote's `payment_hash`, which callers already hold): the exit is read through `readLockupFate`,
+  and the VHTLC script cannot supply it, since its `preimageHash` is a `hash160` of the same secret.
+  And the `indexer` parameter widened from `RefundIndexer` to **`LockupSpendIndexer`**, so it must
+  now carry `getVirtualTxs` as well as `getVtxos` — a real `RestIndexerProvider` already does.
+
+  A lockup funded in two sends of which only one exited reports `exited` for the whole thing and
+  leaves the live half unrefunded. That matches `RfqSwapManager`, which reports the same lockup
+  `exited` on the same any-output rule; the two must not disagree.
 - **`RfqSwapManager` can own its own persistence.** New optional
   `RfqSwapManagerDeps.repository`, new `restoreFromRepository()` and `pruneRetiredSwaps()`, and
   `addSwap(swap, origin?)` gains an optional second argument. Nothing narrows and nothing is

package/dist/{chunk-5NPYNQ5V.js → chunk-RIC5ZTZK.js}

@@ -422,8 +422,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) => {
@@ -625,13 +639,11 @@ 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 }
     }
   });
 }
@@ -677,9 +689,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,
+    serverPubkey,
+    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
+  const script = matched.script;
+  const address = matched.address;
+  const matchedTreeParams = {
+    ...treeParams,
+    ...matched.legacy !== void 0 && { legacy: matched.legacy }
+  };
   assertFundable({
     quote,
     invoiceExpiresAt: params.invoice.expiresAt,
@@ -698,7 +719,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     refundAddress,
     senderPubkey,
     secrets,
-    treeParams
+    treeParams: matchedTreeParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -763,7 +784,7 @@ 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 treeParams = {
     solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
@@ -773,9 +794,13 @@ function deriveOnchainSend(input) {
     senderPubkey: input.senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
     refundPkScript: ArkAddress2.decode(input.refundAddress).pkScript
-  });
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  };
+  const { script, address } = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.serverPubkey,
+    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
@@ -950,13 +975,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 }
     }
   });
 }
@@ -980,10 +1003,23 @@ function deriveLightningReceive(input) {
     payoutPubkey: input.payoutPubkey,
     payoutPkScript: ArkAddress2.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.serverPubkey,
+    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
+  return {
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    invoice,
+    refundLocktime,
+    treeParams: {
+      ...treeParams,
+      ...matched.legacy !== void 0 && { legacy: matched.legacy }
+    }
+  };
 }
 async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
@@ -1071,7 +1107,7 @@ 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 treeParams = {
     solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
@@ -1081,9 +1117,13 @@ function deriveOnchainReceive(input) {
     solverRefundPkScript: solverHex(solverRefundPkScriptHex, "profile.solver_refund_pk_script"),
     payoutPubkey: input.payoutPubkey,
     payoutPkScript: ArkAddress2.decode(input.payoutAddress).pkScript
-  });
-  const address = script.address(input.hrp, input.serverPubkey).encode();
-  verifyLockupAddress(quote, address);
+  };
+  const { script, address } = matchQuotedLockup(
+    quote,
+    input.hrp,
+    input.serverPubkey,
+    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,

package/dist/index.cjs

@@ -411,12 +411,30 @@ var swapPrograms = {
   wantAsset: import_sdk2.arkade.parseArtifact(swap_want_asset_program_default),
   wantBtc: import_sdk2.arkade.parseArtifact(swap_want_btc_program_default)
 };
+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, serverPubkey) {
   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,
@@ -426,7 +444,8 @@ function swapProgramBinding(offer, serverPubkey) {
       ...offer.wantAsset && {
         wantAssetTxid: offer.wantAsset.txid.slice().reverse(),
         wantAssetGroupIndex: offer.wantAsset.groupIndex
-      }
+      },
+      ...offer.exitDelay && { exitDelay: offer.exitDelay.value }
     },
     keys: {
       serverKey: serverPubkey,
@@ -447,9 +466,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 +505,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,6 +563,12 @@ function decodeOffer(data) {
   for (const name of ["wantAsset", "offerAsset"]) {
     if (fields[name]?.length === 0) throw new Error(`missing/invalid ${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 need = (name) => {
     const v = fields[name];
     const len = FIELDS[name].width;
@@ -516,16 +580,36 @@ function decodeOffer(data) {
   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),
+    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")
+    emulatorPubkey: need("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) {
@@ -551,6 +635,14 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
   });
   await promoteOfferContract(contractManager, import_base2.hex.encode(expectedPkScript));
 }
+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, arkServerUrl, params) {
   if (Boolean(params.wantAsset) === Boolean(params.offerAsset)) {
     throw new Error("set exactly one of wantAsset (BTC->asset) or offerAsset (asset->BTC)");
@@ -571,7 +663,11 @@ 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 offer = { ...binding, swapPkScript: script.pkScript };
@@ -1512,7 +1608,9 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
     const script = offerVtxoScript(offer, serverPubkey);
     if (import_base6.hex.encode(script.pkScript) !== import_base6.hex.encode(offer.swapPkScript)) return "indeterminate";
     leaves = {
-      cancel: script.functionByName("cancel")?.leafScript,
+      // 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,7 +1622,7 @@ 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";
     }
   }
@@ -1918,8 +2016,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) => {
@@ -2121,13 +2233,11 @@ 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 }
     }
   });
 }
@@ -2173,9 +2283,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,
+    serverPubkey,
+    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
+  const script = matched.script;
+  const address = matched.address;
+  const matchedTreeParams = {
+    ...treeParams,
+    ...matched.legacy !== void 0 && { legacy: matched.legacy }
+  };
   assertFundable({
     quote,
     invoiceExpiresAt: params.invoice.expiresAt,
@@ -2194,7 +2313,7 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
     refundAddress,
     senderPubkey,
     secrets,
-    treeParams
+    treeParams: matchedTreeParams
   };
 }
 var offerTermsFromQuote = (quote, assets) => {
@@ -2259,7 +2378,7 @@ 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 treeParams = {
     solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
@@ -2269,9 +2388,13 @@ function deriveOnchainSend(input) {
     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.serverPubkey,
+    (legacy) => lightningSendVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
@@ -2446,13 +2569,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 }
     }
   });
 }
@@ -2476,10 +2597,23 @@ 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.serverPubkey,
+    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
+  return {
+    address: matched.address,
+    swapPkScript: matched.script.pkScript,
+    script: matched.script,
+    invoice,
+    refundLocktime,
+    treeParams: {
+      ...treeParams,
+      ...matched.legacy !== void 0 && { legacy: matched.legacy }
+    }
+  };
 }
 async function requestLightningReceive(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
@@ -2567,7 +2701,7 @@ 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 treeParams = {
     solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
@@ -2577,9 +2711,13 @@ function deriveOnchainReceive(input) {
     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.serverPubkey,
+    (legacy) => receiveVtxoScript({ ...treeParams, ...legacy !== void 0 && { legacy } })
+  );
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
@@ -2820,10 +2958,10 @@ async function pushRefundWithoutReceiver(ark, input) {
       input.script.options.refundLocktime
     );
   }
-  const refundPkScript = input.refundPkScript ?? input.script.options.nonInteractiveRefund?.senderPkScript;
+  const refundPkScript = input.refundPkScript ?? input.script.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();
@@ -2875,6 +3013,21 @@ 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) {
+      let fate = { fate: "unknown" };
+      try {
+        fate = await readLockupFate(indexer, {
+          swapPkScript: input.script.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.script.pkScript);
       if (vtxos.length === 0) return { outcome: "nothing_to_refund", status };
       try {