@arkade-os/swap 0.0.8 → 0.0.10

package/README.md

@@ -7,6 +7,11 @@ Node-specific APIs, so it runs in Node, the browser, and React Native alike. Fou
 ship — in-memory (anywhere, nothing outlives the process), IndexedDB (browser), SQLite and Realm
 (React Native, on subpath entry points) — see "Storage backends" below.
 
+The one global the core API requires is `crypto.getRandomValues`. Node and browsers have it;
+React Native does not, so install `react-native-get-random-values` (or `expo-crypto`) and import
+it before this package. `crypto.subtle` is not used. `EventSource` and `WebSocket` are needed only
+by the watch and relay transports, both of which take an injected implementation.
+
 ## Roles
 
 Arkade Intents names two participants:

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

@@ -6,6 +6,7 @@ import * as btc from "@scure/btc-signer";
 var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
 var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
 var MAX_MIN_CONFIRMATIONS = 6;
+var LOCKTIME_THRESHOLD = 5e8;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
@@ -25,6 +26,11 @@ function onchainHtlcScript(params, network) {
       `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
     );
   }
+  if (params.refundLocktime < LOCKTIME_THRESHOLD) {
+    throw new Error(
+      `refundLocktime ${params.refundLocktime} is below LOCKTIME_THRESHOLD (${LOCKTIME_THRESHOLD}) and would be interpreted as a block height`
+    );
+  }
   if (!Object.hasOwn(L1_NETWORKS, network)) {
     throw new Error(
       `unknown L1 network '${String(network)}' \u2014 expected one of ${Object.keys(L1_NETWORKS).join(", ")}`
@@ -211,6 +217,7 @@ async function classifyOnchainHtlc(chain, input) {
 
 // src/claimPacket.ts
 import { base64 } from "@scure/base";
+import { gcm } from "@noble/ciphers/aes.js";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
 import { hkdf } from "@noble/hashes/hkdf.js";
 import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
@@ -231,20 +238,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
   const sharedX = secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
   const key = hkdf(sha2562, sharedX, ephemeralPub, HKDF_INFO, 32);
   if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
-  const aesKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, [
-    "encrypt"
-  ]);
-  const sealed = new Uint8Array(
-    await crypto.subtle.encrypt(
-      {
-        name: "AES-GCM",
-        iv: nonce,
-        additionalData: ephemeralPub
-      },
-      aesKey,
-      input.preimage
-    )
-  );
+  const sealed = gcm(key, nonce, ephemeralPub).encrypt(input.preimage);
   const packet = new Uint8Array(33 + 12 + sealed.length);
   packet.set(ephemeralPub, 0);
   packet.set(nonce, 33);
@@ -318,19 +312,13 @@ import {
   RestArkProvider,
   VHTLC,
   getNetwork,
-  resolveEmulatorPubkey
+  resolveEmulatorPubkey,
+  toXOnly
 } from "@arkade-os/sdk";
 import {
   provisionClaimSecret,
   provisionRefundKey
 } from "@arkade-os/sdk";
-var xOnly = (key, label) => {
-  if (key.length === 32) return key;
-  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
-    throw new Error(`${label} is not a compressed or x-only public key`);
-  }
-  return key.slice(1);
-};
 var solverHex = (value, field) => {
   try {
     return hex3.decode(value);
@@ -651,10 +639,8 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await provisionRefundKey(wallet);
   const senderPubkey = secrets.pubkey;
-  const [info, refundAddress] = await Promise.all([
-    new RestArkProvider(arkServerUrl).getInfo(),
-    wallet.getAddress()
-  ]);
+  const refundAddress = secrets.address;
+  const info = await new RestArkProvider(arkServerUrl).getInfo();
   const quote = await transport.requestQuote(
     lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
   );
@@ -675,21 +661,21 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = xOnly(hex3.decode(info.signerPubkey), "ark signer key");
+  const serverPubkey = toXOnly(hex3.decode(info.signerPubkey), "ark signer key");
   const network = getNetwork(info.network);
   const treeParams = {
-    solverPubkey: xOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
     serverPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    emulatorPubkey: xOnly(
+    emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: ArkAddress2.decode(refundAddress).pkScript
+    refundPkScript: secrets.pkScript
   };
   const script = lightningSendVtxoScript(treeParams);
   const address = script.address(network.hrp, serverPubkey).encode();
@@ -778,7 +764,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -793,7 +779,7 @@ function deriveOnchainSend(input) {
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
-    refundKey: xOnly(hex3.decode(htlcPubkey), "solver L1 htlc key"),
+    refundKey: toXOnly(hex3.decode(htlcPubkey), "solver L1 htlc key"),
     refundLocktime: htlcLocktime
   };
   const htlc = onchainHtlcScript(htlcParams, input.l1Network);
@@ -840,8 +826,8 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: xOnly(hex3.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(
+    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
@@ -984,7 +970,7 @@ function deriveLightningReceive(input) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: xOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1036,8 +1022,8 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: xOnly(hex3.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(
+    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
@@ -1086,7 +1072,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly(hex3.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: toXOnly(hex3.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -1101,7 +1087,7 @@ function deriveOnchainReceive(input) {
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: xOnly(hex3.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: toXOnly(hex3.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -1157,8 +1143,8 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: xOnly(hex3.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(
+    serverPubkey: toXOnly(hex3.decode(info.signerPubkey), "ark signer key"),
+    emulatorPubkey: toXOnly(
       hex3.decode(resolveEmulatorPubkey(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
@@ -1199,6 +1185,7 @@ export {
   ONCHAIN_ORDER_MARGIN_SECONDS,
   ONCHAIN_CLAIM_MARGIN_SECONDS,
   MAX_MIN_CONFIRMATIONS,
+  LOCKTIME_THRESHOLD,
   ONCHAIN_SECONDS_PER_BLOCK,
   ONCHAIN_DUST_SATS,
   newPreimage,

package/dist/index.cjs

@@ -39,6 +39,7 @@ __export(index_exports, {
   LIGHTNING_BTC: () => LIGHTNING_BTC,
   LIGHTNING_RECEIVE_PAIR: () => LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR: () => LIGHTNING_SEND_PAIR,
+  LOCKTIME_THRESHOLD: () => LOCKTIME_THRESHOLD,
   LockupAmountMismatchError: () => LockupAmountMismatchError,
   LockupContractMissing: () => LockupContractMissing,
   LockupNeedsRecoveryError: () => LockupNeedsRecoveryError,
@@ -608,8 +609,8 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
     // script and the payout script comes from wallet.getAddress(), so the
     // client's network (which only shapes address derivation) is unused here
   });
-  const serverKey = swapAddress ? import_sdk2.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
-  const { program, args, keys } = swapProgramBinding(offer, serverKey);
+  const operatorPubkey = swapAddress ? import_sdk2.ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
   const rebuilt = new import_sdk2.arkade.ArkadeProgramScript(program, args, keys);
   if (import_base2.hex.encode(rebuilt.pkScript) !== import_base2.hex.encode(offer.swapPkScript)) {
     throw new Error(
@@ -1050,6 +1051,7 @@ var btc = __toESM(require("@scure/btc-signer"), 1);
 var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
 var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
 var MAX_MIN_CONFIRMATIONS = 6;
+var LOCKTIME_THRESHOLD = 5e8;
 var ONCHAIN_SECONDS_PER_BLOCK = 600;
 var ONCHAIN_DUST_SATS = BigInt(330);
 var newPreimage = () => crypto.getRandomValues(new Uint8Array(32));
@@ -1069,6 +1071,11 @@ function onchainHtlcScript(params, network) {
       `refundLocktime must be a positive unix timestamp, got ${params.refundLocktime}`
     );
   }
+  if (params.refundLocktime < LOCKTIME_THRESHOLD) {
+    throw new Error(
+      `refundLocktime ${params.refundLocktime} is below LOCKTIME_THRESHOLD (${LOCKTIME_THRESHOLD}) and would be interpreted as a block height`
+    );
+  }
   if (!Object.hasOwn(L1_NETWORKS, network)) {
     throw new Error(
       `unknown L1 network '${String(network)}' \u2014 expected one of ${Object.keys(L1_NETWORKS).join(", ")}`
@@ -1723,6 +1730,7 @@ var import_sdk10 = require("@arkade-os/sdk");
 
 // src/claimPacket.ts
 var import_base8 = require("@scure/base");
+var import_aes = require("@noble/ciphers/aes.js");
 var import_secp256k1 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
 var import_sha23 = require("@noble/hashes/sha2.js");
@@ -1743,20 +1751,7 @@ async function sealWithEntropy(input, ephemeralKey, nonce) {
   const sharedX = import_secp256k1.secp256k1.getSharedSecret(ephemeralKey, input.covclaimdPubkey, true).subarray(1);
   const key = (0, import_hkdf.hkdf)(import_sha23.sha256, sharedX, ephemeralPub, HKDF_INFO, 32);
   if (nonce.length !== 12) throw new Error("nonce must be 12 bytes");
-  const aesKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, [
-    "encrypt"
-  ]);
-  const sealed = new Uint8Array(
-    await crypto.subtle.encrypt(
-      {
-        name: "AES-GCM",
-        iv: nonce,
-        additionalData: ephemeralPub
-      },
-      aesKey,
-      input.preimage
-    )
-  );
+  const sealed = (0, import_aes.gcm)(key, nonce, ephemeralPub).encrypt(input.preimage);
   const packet = new Uint8Array(33 + 12 + sealed.length);
   packet.set(ephemeralPub, 0);
   packet.set(nonce, 33);
@@ -1820,13 +1815,6 @@ async function lockupContractParams(contracts, lockupAddress) {
 }
 
 // src/rfq.ts
-var xOnly = (key, label) => {
-  if (key.length === 32) return key;
-  if (key.length !== 33 || key[0] !== 2 && key[0] !== 3) {
-    throw new Error(`${label} is not a compressed or x-only public key`);
-  }
-  return key.slice(1);
-};
 var solverHex = (value, field) => {
   try {
     return import_base10.hex.decode(value);
@@ -2147,10 +2135,8 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
   const rfqId = params.rfqId ?? newRfqId();
   const secrets = await (0, import_sdk10.provisionRefundKey)(wallet);
   const senderPubkey = secrets.pubkey;
-  const [info, refundAddress] = await Promise.all([
-    new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
-    wallet.getAddress()
-  ]);
+  const refundAddress = secrets.address;
+  const info = await new import_sdk9.RestArkProvider(arkServerUrl).getInfo();
   const quote = await transport.requestQuote(
     lightningSendRequest({ rfqId, invoice: params.invoice.raw, refundAddress, senderPubkey })
   );
@@ -2171,21 +2157,21 @@ async function requestLightningSend(wallet, arkServerUrl, transport, params) {
       `quote from_amount ${quote.from_amount} is below the invoice amount \u2014 a negative spread is not a quote`
     );
   }
-  const serverPubkey = xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key");
+  const serverPubkey = (0, import_sdk9.toXOnly)(import_base10.hex.decode(info.signerPubkey), "ark signer key");
   const network = (0, import_sdk9.getNetwork)(info.network);
   const treeParams = {
-    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime: quote.refund_locktime,
     serverPubkey,
     paymentHash: params.invoice.paymentHash,
     claimDelay: unilateralClaimDelay(Number(info.unilateralExitDelay)),
-    emulatorPubkey: xOnly(
+    emulatorPubkey: (0, import_sdk9.toXOnly)(
       import_base10.hex.decode((0, import_sdk9.resolveEmulatorPubkey)(network, params.emulatorPubkey)),
       "emulator signer key"
     ),
     senderPubkey,
     receiverPkScript: solverHex(receiverPkScriptHex, "profile.receiver_pk_script"),
-    refundPkScript: import_sdk9.ArkAddress.decode(refundAddress).pkScript
+    refundPkScript: secrets.pkScript
   };
   const script = lightningSendVtxoScript(treeParams);
   const address = script.address(network.hrp, serverPubkey).encode();
@@ -2274,7 +2260,7 @@ function deriveOnchainSend(input) {
     throw new Error("onchain-send quote is missing a binding field");
   }
   const script = lightningSendVtxoScript({
-    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2289,7 +2275,7 @@ function deriveOnchainSend(input) {
   const htlcParams = {
     paymentHash: input.paymentHash,
     claimKey: input.payoutPubkey,
-    refundKey: xOnly(import_base10.hex.decode(htlcPubkey), "solver L1 htlc key"),
+    refundKey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(htlcPubkey), "solver L1 htlc key"),
     refundLocktime: htlcLocktime
   };
   const htlc = onchainHtlcScript(htlcParams, input.l1Network);
@@ -2336,8 +2322,8 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
     quote,
     paymentHash,
     payoutPubkey: params.payoutPubkey,
-    serverPubkey: xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(
+    serverPubkey: (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"
     ),
@@ -2480,7 +2466,7 @@ function deriveLightningReceive(input) {
     throw new Error("lightning-receive quote is missing a binding field");
   }
   const treeParams = {
-    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2532,8 +2518,8 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     paymentHash,
     payoutPubkey,
     payoutAddress,
-    serverPubkey: xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(
+    serverPubkey: (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"
     ),
@@ -2582,7 +2568,7 @@ function deriveOnchainReceive(input) {
     throw new Error("onchain-receive quote is missing a binding field");
   }
   const script = receiveVtxoScript({
-    solverPubkey: xOnly(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
+    solverPubkey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(quote.solver_pubkey), "solver key"),
     refundLocktime,
     serverPubkey: input.serverPubkey,
     paymentHash: input.paymentHash,
@@ -2597,7 +2583,7 @@ function deriveOnchainReceive(input) {
   const htlc = onchainHtlcScript(
     {
       paymentHash: input.paymentHash,
-      claimKey: xOnly(import_base10.hex.decode(claimPubkey), "solver L1 claim key"),
+      claimKey: (0, import_sdk9.toXOnly)(import_base10.hex.decode(claimPubkey), "solver L1 claim key"),
       refundKey: input.refundPubkey,
       refundLocktime: htlcLocktime
     },
@@ -2653,8 +2639,8 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     payoutPubkey,
     payoutAddress,
     refundPubkey: params.refundPubkey,
-    serverPubkey: xOnly(import_base10.hex.decode(info.signerPubkey), "ark signer key"),
-    emulatorPubkey: xOnly(
+    serverPubkey: (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"
     ),
@@ -2759,6 +2745,7 @@ async function findLockupVtxos(indexer, swapPkScript) {
     [recoverable.vtxos ?? [], true]
   ]) {
     for (const vtxo of vtxos) {
+      if (vtxo.isUnrolled) continue;
       const key = `${vtxo.txid}:${vtxo.vout}`;
       if (seen.has(key)) continue;
       seen.add(key);
@@ -2781,10 +2768,17 @@ async function readLockupFate(indexer, input) {
   const { vtxos } = await indexer.getVtxos({ scripts: [import_base11.hex.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
+  const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk11.hasTerminalSpend)(vtxo));
+  if (exited.length > 0) {
+    return {
+      fate: "exited",
+      outpoints: exited.map((vtxo) => ({ txid: vtxo.txid, vout: vtxo.vout }))
+    };
+  }
   const spentBy = /* @__PURE__ */ new Map();
   let everySpendNamed = true;
   for (const vtxo of all) {
-    if (!vtxo.isSpent && !vtxo.spentBy && !vtxo.settledBy) return { fate: "open" };
+    if (!(0, import_sdk11.hasTerminalSpend)(vtxo)) return { fate: "open" };
     if (vtxo.spentBy)
       spentBy.set(vtxo.spentBy, {
         checkpointTxid: vtxo.spentBy,
@@ -3672,12 +3666,36 @@ var RfqSwapManager = class {
       this.setState(swap, fate.fate === "claimed" ? "settled" : "refunded");
       return;
     }
-    if (swap.kind === "lightning_receive") return this.driveReceiveClaim(swap);
+    if (swap.kind === "lightning_receive") {
+      return fate.fate === "exited" ? this.blockExitedLockup(swap, fate) : this.driveReceiveClaim(swap);
+    }
     if (swap.kind === "onchain_send" && swap.state !== "claimed") {
       if (await this.driveOnchain(swap) === "handled") return;
     }
+    if (fate.fate === "exited") {
+      const claiming = swap.state === "claimable" || swap.state === "claimed";
+      if (this.config.now() < swap.refundLocktime && claiming) return;
+      return this.blockExitedLockup(swap, fate);
+    }
     await this.driveArkadeRefund(swap);
   }
+  /**
+   * The lockup was unilaterally exited: its outputs sit onchain under the
+   * VHTLC script, where no offchain claim or refund can reach them.
+   *
+   * `needs_counterparty` rather than a terminal state, because the money still
+   * needs action and the swap can still end either way — an onchain claim can
+   * reveal the preimage, an onchain refund can return it — and that state is
+   * documented as re-checked every pass. It must be set from HERE and not from
+   * inside `driveArkadeRefund`, whose two `unblock` calls would lift it again
+   * on the very next pass.
+   */
+  blockExitedLockup(swap, fate) {
+    this.block(
+      swap,
+      `the lockup was unilaterally exited (${fate.outpoints.length} output(s) onchain), so no offchain spend can move it \u2014 complete the unroll and spend it onchain`
+    );
+  }
   /**
    * The receive leg's whole state machine: claim the solver-funded lockup
    * while the window is open, and recognise the shapes in which it can be
@@ -4182,6 +4200,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   LIGHTNING_BTC,
   LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR,
+  LOCKTIME_THRESHOLD,
   LockupAmountMismatchError,
   LockupContractMissing,
   LockupNeedsRecoveryError,

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 import { ProvisionedKey, ProvisionedClaimSecret, asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, VHTLC, Identity, ActivityResolver } from '@arkade-os/sdk';
-import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, b as RefundArkProvider, c as RefundIndexer, L as LockupVtxo, d as RfqSwap, e as ArkadeRefundResult, f as LockupSpendIndexer, g as RfqSwapState } from './repository-Dso34L4D.cjs';
-export { h as AssetSwapStatus, i as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, j as LightningReceiveSwap, k as LightningSendSwap, l as LockupFate, m as LockupNeedsRecoveryError, n as LockupParams, o as LockupSpend, O as OnchainSendAction, p as OnchainSendSwap, P as PersistableRfqSwap, q as PreimageBlockedReason, r as PreimageNotRecoverableError, s as REFUND_MTP_LAG_SECONDS, t as RFQ_RESOLVED_STATES, u as RFQ_SWAP_RETENTION_SECONDS, v as RFQ_SWAP_TERMINAL_STATES, w as RefundOutcome, x as RfqRestoreFailure, y as RfqRestoreOptions, z as RfqRestoreResult, C as RfqSwapActionName, D as RfqSwapLockup, E as RfqSwapManager, F as RfqSwapManagerCallbacks, G as RfqSwapManagerConfig, H as RfqSwapManagerDeps, J as RfqSwapManagerEvents, K as RfqSwapOrigin, N as RfqSwapOriginRequired, Q as RfqSwapOutcome, T as RfqSwapRecordStore, U as SwapContractRegistry, V as addAssetSwap, W as awaitRfqResolution, X as createRfqSwapRecord, Y as findLockupVtxos, Z as getAssetSwaps, _ as getAssetSwapsOrThrow, $ as isRfqSwapTerminal, a0 as isRfqTerminal, a1 as nextOnchainAction, a2 as preimageForSwapRecord, a3 as pushRefundWithoutReceiver, a4 as readLockupFate, a5 as rebuildRfqSwap, a6 as refundIfUnresolved, a7 as rfqSwapOriginOf, a8 as shouldRetainRfqSwap, a9 as swapSecretsToRecord, aa as updateAssetSwap, ab as updateAssetSwapBestEffort, ac as updateRfqSwapRecord } from './repository-Dso34L4D.cjs';
+import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, b as RefundArkProvider, c as RefundIndexer, L as LockupVtxo, d as RfqSwap, e as ArkadeRefundResult, f as LockupSpendIndexer, g as RfqSwapState } from './repository-C8FXlmHY.cjs';
+export { h as AssetSwapStatus, i as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, j as LightningReceiveSwap, k as LightningSendSwap, l as LockupFate, m as LockupNeedsRecoveryError, n as LockupParams, o as LockupSpend, O as OnchainSendAction, p as OnchainSendSwap, P as PersistableRfqSwap, q as PreimageBlockedReason, r as PreimageNotRecoverableError, s as REFUND_MTP_LAG_SECONDS, t as RFQ_RESOLVED_STATES, u as RFQ_SWAP_RETENTION_SECONDS, v as RFQ_SWAP_TERMINAL_STATES, w as RefundOutcome, x as RfqRestoreFailure, y as RfqRestoreOptions, z as RfqRestoreResult, C as RfqSwapActionName, D as RfqSwapLockup, E as RfqSwapManager, F as RfqSwapManagerCallbacks, G as RfqSwapManagerConfig, H as RfqSwapManagerDeps, J as RfqSwapManagerEvents, K as RfqSwapOrigin, N as RfqSwapOriginRequired, Q as RfqSwapOutcome, T as RfqSwapRecordStore, U as SwapContractRegistry, V as addAssetSwap, W as awaitRfqResolution, X as createRfqSwapRecord, Y as findLockupVtxos, Z as getAssetSwaps, _ as getAssetSwapsOrThrow, $ as isRfqSwapTerminal, a0 as isRfqTerminal, a1 as nextOnchainAction, a2 as preimageForSwapRecord, a3 as pushRefundWithoutReceiver, a4 as readLockupFate, a5 as rebuildRfqSwap, a6 as refundIfUnresolved, a7 as rfqSwapOriginOf, a8 as shouldRetainRfqSwap, a9 as swapSecretsToRecord, aa as updateAssetSwap, ab as updateAssetSwapBestEffort, ac as updateRfqSwapRecord } from './repository-C8FXlmHY.cjs';
 import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
-import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams } from './rfq-C-aq5LDJ.cjs';
-export { A as ARKADE_ASSET, c as ARKADE_BTC, d as AddressMismatch, C as ChainSource, e as ChainUtxo, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, h as LightningReceiveTreeParams, i as LightningSendTreeParams, M as MAX_MIN_CONFIRMATIONS, j as MIN_CLAIM_WINDOW_SECONDS, k as MIN_HEADROOM_SECONDS, l as ONCHAIN_BTC, m as ONCHAIN_CLAIM_MARGIN_SECONDS, n as ONCHAIN_DUST_SATS, o as ONCHAIN_ORDER_MARGIN_SECONDS, p as ONCHAIN_RECEIVE_PAIR, q as ONCHAIN_SECONDS_PER_BLOCK, r as ONCHAIN_SEND_PAIR, s as OnchainHtlcPhase, R as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, w as RfqStatus, x as RfqTransport, S as SOLO_REFUND_HEADROOM_SECONDS, y as SwapRefusal, z as arkadeAssetLeg, B as arkadeSwapRequest, D as assertFundable, E as assertReceivable, F as awaitOnchainFill, G as buildHtlcClaim, J as buildHtlcRefund, K as claimOnchainFill, N as classifyOnchainHtlc, P as deriveLightningReceive, Q as deriveOnchainReceive, T as deriveOnchainSend, U as extractPreimage, V as httpTransport, W as lightningReceiveRequest, X as lightningSendRequest, Y as lightningSendVtxoScript, Z as newPreimage, _ as newRfqId, $ as offerTermsFromQuote, a0 as onchainHtlcScript, a1 as onchainReceiveRequest, a2 as onchainSendRequest, a3 as paymentHashOf, a4 as receiveVtxoScript, a5 as relayTransport, a6 as requestLightningReceive, a7 as requestLightningSend, a8 as requestOnchainReceive, a9 as requestOnchainSend, aa as rfqPair, ab as unilateralClaimDelay, ac as unilateralRefundDelay, ad as unilateralRefundWithoutReceiverDelay, ae as verifyLockupAddress, af as verifyReceiveInvoice } from './rfq-C-aq5LDJ.cjs';
+import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams } from './rfq-DglvHMNC.cjs';
+export { A as ARKADE_ASSET, c as ARKADE_BTC, d as AddressMismatch, C as ChainSource, e as ChainUtxo, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, h as LOCKTIME_THRESHOLD, i as LightningReceiveTreeParams, j as LightningSendTreeParams, M as MAX_MIN_CONFIRMATIONS, k as MIN_CLAIM_WINDOW_SECONDS, l as MIN_HEADROOM_SECONDS, m as ONCHAIN_BTC, n as ONCHAIN_CLAIM_MARGIN_SECONDS, o as ONCHAIN_DUST_SATS, p as ONCHAIN_ORDER_MARGIN_SECONDS, q as ONCHAIN_RECEIVE_PAIR, r as ONCHAIN_SECONDS_PER_BLOCK, s as ONCHAIN_SEND_PAIR, t as OnchainHtlcPhase, R as RFQ_TERMINAL_STATES, u as RelaySocket, v as RfqQuote, w as RfqRefusalReason, x as RfqStatus, y as RfqTransport, S as SOLO_REFUND_HEADROOM_SECONDS, z as SwapRefusal, B as arkadeAssetLeg, D as arkadeSwapRequest, E as assertFundable, F as assertReceivable, G as awaitOnchainFill, J as buildHtlcClaim, K as buildHtlcRefund, N as claimOnchainFill, P as classifyOnchainHtlc, Q as deriveLightningReceive, T as deriveOnchainReceive, U as deriveOnchainSend, V as extractPreimage, W as httpTransport, X as lightningReceiveRequest, Y as lightningSendRequest, Z as lightningSendVtxoScript, _ as newPreimage, $ as newRfqId, a0 as offerTermsFromQuote, a1 as onchainHtlcScript, a2 as onchainReceiveRequest, a3 as onchainSendRequest, a4 as paymentHashOf, a5 as receiveVtxoScript, a6 as relayTransport, a7 as requestLightningReceive, a8 as requestLightningSend, a9 as requestOnchainReceive, aa as requestOnchainSend, ab as rfqPair, ac as unilateralClaimDelay, ad as unilateralRefundDelay, ae as unilateralRefundWithoutReceiverDelay, af as verifyLockupAddress, ag as verifyReceiveInvoice } from './rfq-DglvHMNC.cjs';
 
 /**
  * Which wallet key signs this leg. Stored at `profile.signer`.
@@ -633,7 +633,7 @@ interface ClaimPacketInput {
     covclaimdPubkey: Uint8Array;
 }
 /**
- * Seal a preimage to covclaimd. WebCrypto AES-GCM, hence async.
+ * Seal a preimage to covclaimd.
  *
  * The ephemeral key and nonce are generated here and CANNOT be supplied by a
  * caller. That is the point of this signature: AES-GCM under a repeated

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { ProvisionedKey, ProvisionedClaimSecret, asset, IWallet, arkade, RestIndexerProvider, Transaction, IContractManager, VHTLC, Identity, ActivityResolver } from '@arkade-os/sdk';
-import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, b as RefundArkProvider, c as RefundIndexer, L as LockupVtxo, d as RfqSwap, e as ArkadeRefundResult, f as LockupSpendIndexer, g as RfqSwapState } from './repository-BcZ9LXRP.js';
-export { h as AssetSwapStatus, i as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, j as LightningReceiveSwap, k as LightningSendSwap, l as LockupFate, m as LockupNeedsRecoveryError, n as LockupParams, o as LockupSpend, O as OnchainSendAction, p as OnchainSendSwap, P as PersistableRfqSwap, q as PreimageBlockedReason, r as PreimageNotRecoverableError, s as REFUND_MTP_LAG_SECONDS, t as RFQ_RESOLVED_STATES, u as RFQ_SWAP_RETENTION_SECONDS, v as RFQ_SWAP_TERMINAL_STATES, w as RefundOutcome, x as RfqRestoreFailure, y as RfqRestoreOptions, z as RfqRestoreResult, C as RfqSwapActionName, D as RfqSwapLockup, E as RfqSwapManager, F as RfqSwapManagerCallbacks, G as RfqSwapManagerConfig, H as RfqSwapManagerDeps, J as RfqSwapManagerEvents, K as RfqSwapOrigin, N as RfqSwapOriginRequired, Q as RfqSwapOutcome, T as RfqSwapRecordStore, U as SwapContractRegistry, V as addAssetSwap, W as awaitRfqResolution, X as createRfqSwapRecord, Y as findLockupVtxos, Z as getAssetSwaps, _ as getAssetSwapsOrThrow, $ as isRfqSwapTerminal, a0 as isRfqTerminal, a1 as nextOnchainAction, a2 as preimageForSwapRecord, a3 as pushRefundWithoutReceiver, a4 as readLockupFate, a5 as rebuildRfqSwap, a6 as refundIfUnresolved, a7 as rfqSwapOriginOf, a8 as shouldRetainRfqSwap, a9 as swapSecretsToRecord, aa as updateAssetSwap, ab as updateAssetSwapBestEffort, ac as updateRfqSwapRecord } from './repository-BcZ9LXRP.js';
+import { S as SwapSecretsProjection, R as RfqSwapRecord, A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry, b as RefundArkProvider, c as RefundIndexer, L as LockupVtxo, d as RfqSwap, e as ArkadeRefundResult, f as LockupSpendIndexer, g as RfqSwapState } from './repository-Cw2EvvZG.js';
+export { h as AssetSwapStatus, i as AvailableRfqSwapManagerCallbacks, B as BTC_ASSET_ID, I as InMemoryAssetSwapRepository, j as LightningReceiveSwap, k as LightningSendSwap, l as LockupFate, m as LockupNeedsRecoveryError, n as LockupParams, o as LockupSpend, O as OnchainSendAction, p as OnchainSendSwap, P as PersistableRfqSwap, q as PreimageBlockedReason, r as PreimageNotRecoverableError, s as REFUND_MTP_LAG_SECONDS, t as RFQ_RESOLVED_STATES, u as RFQ_SWAP_RETENTION_SECONDS, v as RFQ_SWAP_TERMINAL_STATES, w as RefundOutcome, x as RfqRestoreFailure, y as RfqRestoreOptions, z as RfqRestoreResult, C as RfqSwapActionName, D as RfqSwapLockup, E as RfqSwapManager, F as RfqSwapManagerCallbacks, G as RfqSwapManagerConfig, H as RfqSwapManagerDeps, J as RfqSwapManagerEvents, K as RfqSwapOrigin, N as RfqSwapOriginRequired, Q as RfqSwapOutcome, T as RfqSwapRecordStore, U as SwapContractRegistry, V as addAssetSwap, W as awaitRfqResolution, X as createRfqSwapRecord, Y as findLockupVtxos, Z as getAssetSwaps, _ as getAssetSwapsOrThrow, $ as isRfqSwapTerminal, a0 as isRfqTerminal, a1 as nextOnchainAction, a2 as preimageForSwapRecord, a3 as pushRefundWithoutReceiver, a4 as readLockupFate, a5 as rebuildRfqSwap, a6 as refundIfUnresolved, a7 as rfqSwapOriginOf, a8 as shouldRetainRfqSwap, a9 as swapSecretsToRecord, aa as updateAssetSwap, ab as updateAssetSwapBestEffort, ac as updateRfqSwapRecord } from './repository-Cw2EvvZG.js';
 import { Network, LocalCardInput, DiscoveredMarket, Side, OfferPlan } from '@arkade-os/solver-discovery';
-import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams } from './rfq-C-aq5LDJ.js';
-export { A as ARKADE_ASSET, c as ARKADE_BTC, d as AddressMismatch, C as ChainSource, e as ChainUtxo, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, h as LightningReceiveTreeParams, i as LightningSendTreeParams, M as MAX_MIN_CONFIRMATIONS, j as MIN_CLAIM_WINDOW_SECONDS, k as MIN_HEADROOM_SECONDS, l as ONCHAIN_BTC, m as ONCHAIN_CLAIM_MARGIN_SECONDS, n as ONCHAIN_DUST_SATS, o as ONCHAIN_ORDER_MARGIN_SECONDS, p as ONCHAIN_RECEIVE_PAIR, q as ONCHAIN_SECONDS_PER_BLOCK, r as ONCHAIN_SEND_PAIR, s as OnchainHtlcPhase, R as RFQ_TERMINAL_STATES, t as RelaySocket, u as RfqQuote, v as RfqRefusalReason, w as RfqStatus, x as RfqTransport, S as SOLO_REFUND_HEADROOM_SECONDS, y as SwapRefusal, z as arkadeAssetLeg, B as arkadeSwapRequest, D as assertFundable, E as assertReceivable, F as awaitOnchainFill, G as buildHtlcClaim, J as buildHtlcRefund, K as claimOnchainFill, N as classifyOnchainHtlc, P as deriveLightningReceive, Q as deriveOnchainReceive, T as deriveOnchainSend, U as extractPreimage, V as httpTransport, W as lightningReceiveRequest, X as lightningSendRequest, Y as lightningSendVtxoScript, Z as newPreimage, _ as newRfqId, $ as offerTermsFromQuote, a0 as onchainHtlcScript, a1 as onchainReceiveRequest, a2 as onchainSendRequest, a3 as paymentHashOf, a4 as receiveVtxoScript, a5 as relayTransport, a6 as requestLightningReceive, a7 as requestLightningSend, a8 as requestOnchainReceive, a9 as requestOnchainSend, aa as rfqPair, ab as unilateralClaimDelay, ac as unilateralRefundDelay, ad as unilateralRefundWithoutReceiverDelay, ae as verifyLockupAddress, af as verifyReceiveInvoice } from './rfq-C-aq5LDJ.js';
+import { O as OnchainNetwork, a as OnchainHtlc, b as OnchainHtlcParams } from './rfq-DglvHMNC.js';
+export { A as ARKADE_ASSET, c as ARKADE_BTC, d as AddressMismatch, C as ChainSource, e as ChainUtxo, H as HtlcUtxo, I as InvoiceFacts, L as LIGHTNING_BTC, f as LIGHTNING_RECEIVE_PAIR, g as LIGHTNING_SEND_PAIR, h as LOCKTIME_THRESHOLD, i as LightningReceiveTreeParams, j as LightningSendTreeParams, M as MAX_MIN_CONFIRMATIONS, k as MIN_CLAIM_WINDOW_SECONDS, l as MIN_HEADROOM_SECONDS, m as ONCHAIN_BTC, n as ONCHAIN_CLAIM_MARGIN_SECONDS, o as ONCHAIN_DUST_SATS, p as ONCHAIN_ORDER_MARGIN_SECONDS, q as ONCHAIN_RECEIVE_PAIR, r as ONCHAIN_SECONDS_PER_BLOCK, s as ONCHAIN_SEND_PAIR, t as OnchainHtlcPhase, R as RFQ_TERMINAL_STATES, u as RelaySocket, v as RfqQuote, w as RfqRefusalReason, x as RfqStatus, y as RfqTransport, S as SOLO_REFUND_HEADROOM_SECONDS, z as SwapRefusal, B as arkadeAssetLeg, D as arkadeSwapRequest, E as assertFundable, F as assertReceivable, G as awaitOnchainFill, J as buildHtlcClaim, K as buildHtlcRefund, N as claimOnchainFill, P as classifyOnchainHtlc, Q as deriveLightningReceive, T as deriveOnchainReceive, U as deriveOnchainSend, V as extractPreimage, W as httpTransport, X as lightningReceiveRequest, Y as lightningSendRequest, Z as lightningSendVtxoScript, _ as newPreimage, $ as newRfqId, a0 as offerTermsFromQuote, a1 as onchainHtlcScript, a2 as onchainReceiveRequest, a3 as onchainSendRequest, a4 as paymentHashOf, a5 as receiveVtxoScript, a6 as relayTransport, a7 as requestLightningReceive, a8 as requestLightningSend, a9 as requestOnchainReceive, aa as requestOnchainSend, ab as rfqPair, ac as unilateralClaimDelay, ad as unilateralRefundDelay, ae as unilateralRefundWithoutReceiverDelay, af as verifyLockupAddress, ag as verifyReceiveInvoice } from './rfq-DglvHMNC.js';
 
 /**
  * Which wallet key signs this leg. Stored at `profile.signer`.
@@ -633,7 +633,7 @@ interface ClaimPacketInput {
     covclaimdPubkey: Uint8Array;
 }
 /**
- * Seal a preimage to covclaimd. WebCrypto AES-GCM, hence async.
+ * Seal a preimage to covclaimd.
  *
  * The ephemeral key and nonce are generated here and CANNOT be supplied by a
  * caller. That is the point of this signature: AES-GCM under a repeated

package/dist/index.js

@@ -5,6 +5,7 @@ import {
   LIGHTNING_BTC,
   LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR,
+  LOCKTIME_THRESHOLD,
   LockupContractMissing,
   LockupRegistrationFailed,
   MAX_MIN_CONFIRMATIONS,
@@ -62,7 +63,7 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-TU4NGZDP.js";
+} from "./chunk-5NPYNQ5V.js";
 import {
   InMemoryAssetSwapRepository,
   marketsCacheKey
@@ -526,8 +527,8 @@ async function cancelOffer(wallet, arkServerUrl, offerHex, opts) {
     // script and the payout script comes from wallet.getAddress(), so the
     // client's network (which only shapes address derivation) is unused here
   });
-  const serverKey = swapAddress ? ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
-  const { program, args, keys } = swapProgramBinding(offer, serverKey);
+  const operatorPubkey = swapAddress ? ArkAddress.decode(swapAddress).serverPubKey : client.serverKey;
+  const { program, args, keys } = swapProgramBinding(offer, operatorPubkey);
   const rebuilt = new arkade.ArkadeProgramScript(program, args, keys);
   if (hex2.encode(rebuilt.pkScript) !== hex2.encode(offer.swapPkScript)) {
     throw new Error(
@@ -1411,6 +1412,7 @@ import {
   assertSubmittedArkTxid,
   buildOffchainTx,
   getArkPsbtFields,
+  hasTerminalSpend,
   matchServerCheckpoints
 } from "@arkade-os/sdk";
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -1471,6 +1473,7 @@ async function findLockupVtxos(indexer, swapPkScript) {
     [recoverable.vtxos ?? [], true]
   ]) {
     for (const vtxo of vtxos) {
+      if (vtxo.isUnrolled) continue;
       const key = `${vtxo.txid}:${vtxo.vout}`;
       if (seen.has(key)) continue;
       seen.add(key);
@@ -1493,10 +1496,17 @@ async function readLockupFate(indexer, input) {
   const { vtxos } = await indexer.getVtxos({ scripts: [hex7.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
+  const exited = all.filter((vtxo) => vtxo.isUnrolled && !hasTerminalSpend(vtxo));
+  if (exited.length > 0) {
+    return {
+      fate: "exited",
+      outpoints: exited.map((vtxo) => ({ txid: vtxo.txid, vout: vtxo.vout }))
+    };
+  }
   const spentBy = /* @__PURE__ */ new Map();
   let everySpendNamed = true;
   for (const vtxo of all) {
-    if (!vtxo.isSpent && !vtxo.spentBy && !vtxo.settledBy) return { fate: "open" };
+    if (!hasTerminalSpend(vtxo)) return { fate: "open" };
     if (vtxo.spentBy)
       spentBy.set(vtxo.spentBy, {
         checkpointTxid: vtxo.spentBy,
@@ -2388,12 +2398,36 @@ var RfqSwapManager = class {
       this.setState(swap, fate.fate === "claimed" ? "settled" : "refunded");
       return;
     }
-    if (swap.kind === "lightning_receive") return this.driveReceiveClaim(swap);
+    if (swap.kind === "lightning_receive") {
+      return fate.fate === "exited" ? this.blockExitedLockup(swap, fate) : this.driveReceiveClaim(swap);
+    }
     if (swap.kind === "onchain_send" && swap.state !== "claimed") {
       if (await this.driveOnchain(swap) === "handled") return;
     }
+    if (fate.fate === "exited") {
+      const claiming = swap.state === "claimable" || swap.state === "claimed";
+      if (this.config.now() < swap.refundLocktime && claiming) return;
+      return this.blockExitedLockup(swap, fate);
+    }
     await this.driveArkadeRefund(swap);
   }
+  /**
+   * The lockup was unilaterally exited: its outputs sit onchain under the
+   * VHTLC script, where no offchain claim or refund can reach them.
+   *
+   * `needs_counterparty` rather than a terminal state, because the money still
+   * needs action and the swap can still end either way — an onchain claim can
+   * reveal the preimage, an onchain refund can return it — and that state is
+   * documented as re-checked every pass. It must be set from HERE and not from
+   * inside `driveArkadeRefund`, whose two `unblock` calls would lift it again
+   * on the very next pass.
+   */
+  blockExitedLockup(swap, fate) {
+    this.block(
+      swap,
+      `the lockup was unilaterally exited (${fate.outpoints.length} output(s) onchain), so no offchain spend can move it \u2014 complete the unroll and spend it onchain`
+    );
+  }
   /**
    * The receive leg's whole state machine: claim the solver-funded lockup
    * while the window is open, and recognise the shapes in which it can be
@@ -2899,6 +2933,7 @@ export {
   LIGHTNING_BTC,
   LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR,
+  LOCKTIME_THRESHOLD,
   LockupAmountMismatchError,
   LockupContractMissing,
   LockupNeedsRecoveryError,

package/dist/nostr.cjs

@@ -62,6 +62,7 @@ var import_sdk3 = require("@arkade-os/sdk");
 
 // src/claimPacket.ts
 var import_base2 = require("@scure/base");
+var import_aes = require("@noble/ciphers/aes.js");
 var import_secp256k1 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
 var import_sha22 = require("@noble/hashes/sha2.js");

package/dist/nostr.d.cts

@@ -1,4 +1,4 @@
-import { x as RfqTransport } from './rfq-C-aq5LDJ.cjs';
+import { y as RfqTransport } from './rfq-DglvHMNC.cjs';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.d.ts

@@ -1,4 +1,4 @@
-import { x as RfqTransport } from './rfq-C-aq5LDJ.js';
+import { y as RfqTransport } from './rfq-DglvHMNC.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.js

@@ -1,7 +1,7 @@
 import {
   expectQuote,
   pairOf
-} from "./chunk-TU4NGZDP.js";
+} from "./chunk-5NPYNQ5V.js";
 
 // src/nostr.ts
 import {

package/dist/repositories/realm/index.d.cts

@@ -1,8 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-Dso34L4D.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-C8FXlmHY.cjs';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-C-aq5LDJ.cjs';
+import '../../rfq-DglvHMNC.cjs';
 
 /**
  * Realm backend for React Native.

package/dist/repositories/realm/index.d.ts

@@ -1,8 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-BcZ9LXRP.js';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-Cw2EvvZG.js';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-C-aq5LDJ.js';
+import '../../rfq-DglvHMNC.js';
 
 /**
  * Realm backend for React Native.

package/dist/repositories/sqlite/index.d.cts

@@ -1,8 +1,8 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-Dso34L4D.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-C8FXlmHY.cjs';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-C-aq5LDJ.cjs';
+import '../../rfq-DglvHMNC.cjs';
 
 /**
  * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in

package/dist/repositories/sqlite/index.d.ts

@@ -1,8 +1,8 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-BcZ9LXRP.js';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-Cw2EvvZG.js';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-C-aq5LDJ.js';
+import '../../rfq-DglvHMNC.js';
 
 /**
  * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in

package/dist/{repository-Dso34L4D.d.cts → repository-C8FXlmHY.d.cts}

@@ -1,6 +1,6 @@
 import { DiscoveredMarket } from '@arkade-os/solver-discovery';
 import { IWallet, ProvisionedKey, ProvisionedClaimSecret, RestArkProvider, RestIndexerProvider, VHTLC, Identity, IContractManager } from '@arkade-os/sdk';
-import { w as RfqStatus, x as RfqTransport, a as OnchainHtlc, e as ChainUtxo, C as ChainSource, s as OnchainHtlcPhase } from './rfq-C-aq5LDJ.cjs';
+import { x as RfqStatus, y as RfqTransport, a as OnchainHtlc, e as ChainUtxo, C as ChainSource, t as OnchainHtlcPhase } from './rfq-DglvHMNC.cjs';
 
 type AssetSwapStatus = "pending" | "cancelling" | "fulfilled" | "cancelled" | "recoverable" | "awaiting_fill" | "claimable" | "claimed" | "refunded_l1";
 /** The sentinel asset id for BTC itself, as opposed to a 68-hex asset id.
@@ -227,12 +227,15 @@ interface LockupVtxo {
      * It is still the trader's money and it is still visible, which is why
      * {@link findLockupVtxos} returns it. What it is not is refundable by
      * {@link pushRefundWithoutReceiver}: that builds an offchain Ark
-     * transaction, and the SDK's own predicates make the two states mutually
-     * exclusive — `canSpendOffchain` is false exactly when `canRecoverOnchain`
-     * is true (`wallet/vtxo.ts`), and the latter is documented as "must be
-     * recovered into a fresh batch rather than spent offchain". Holding the
-     * trader's `sender` key does not change that; a sweep removes the leaf from
-     * the live tree, not the signature from the trader.
+     * transaction, and the SDK's own predicates put the two states on opposite
+     * sides — `canSpendOffchain` is false whenever `canRecoverOnchain` is true
+     * (`wallet/vtxo.ts`), and the latter is documented as "must be recovered
+     * into a fresh batch rather than spent offchain". Holding the trader's
+     * `sender` key does not change that; a sweep removes the leaf from the live
+     * tree, not the signature from the trader.
+     *
+     * Opposite, but not exhaustive: an unrolled output satisfies neither, and
+     * {@link findLockupVtxos} drops those before they reach this type at all.
      *
      * `packages/boltz-swap` splits on exactly this fact rather than working
      * around it: `settleRefundWithoutReceiver` sends a live VTXO through an
@@ -321,6 +324,18 @@ declare class LockupNeedsRecoveryError extends Error {
  * That function refuses the recoverable ones by name rather than submitting a
  * spend the server must reject.
  *
+ * **Unrolled outputs are the one exception, and are dropped.** A unilaterally
+ * exited output lives onchain behind its CSV; no offchain spend of any leaf can
+ * reach it, and `LockupVtxo` carries no field to say so, so a caller could not
+ * tell it apart from a live one. Whether arkd returns such an output under
+ * `spendableOnly` is not determinable from here, so the exclusion is made
+ * defensively rather than assumed. It costs the two waiting callers nothing
+ * they wanted: `awaitLockupFunding` keeps waiting for a claimable lockup
+ * instead of publishing `P` into a spend that cannot land, and
+ * `refundIfUnresolved` reports `nothing_to_refund` instead of grinding a doomed
+ * push to its deadline. The manager reads the exit through
+ * {@link readLockupFate}, which queries unfiltered and reports it as `exited`.
+ *
  * This read — not the RFQ's reported state — is the authority on whether
  * there is anything left at the lockup.
  *
@@ -374,6 +389,29 @@ type LockupFate =
     fate: "returned";
     spends: readonly LockupSpend[];
 }
+/**
+ * At least one output was unilaterally exited: it sits onchain under the
+ * VHTLC script, where no offchain claim or refund can reach it.
+ *
+ * Not terminal, and not a loss. The money is still under the same script
+ * with the same leaves, so `completeUnroll` plus an onchain spend can still
+ * end the swap either way — which is why this outranks `open`: an output
+ * that is "still unspent" but unreachable is not a swap that is merely
+ * running.
+ *
+ * It outranks a verdict too, on a lockup where a sibling output was claimed
+ * or returned. That is the rule `open` already sets, not a new one: the
+ * unspent test short-circuits before any witness is read, so a partially
+ * resolved lockup has never reported `claimed`/`returned`. What changes is
+ * only that such a lockup now says why it is unresolved.
+ */
+ | {
+    fate: "exited";
+    outpoints: readonly {
+        txid: string;
+        vout: number;
+    }[];
+}
 /** Nothing was learned: no outputs visible, an output spent by nothing the
  * indexer names, a spend it could not produce, or a blob that would not
  * decode. Never an answer. */
@@ -409,6 +447,11 @@ type LockupFate =
  * response to `unknown` is the same as to `open`: keep watching, and let the
  * refund timelock — which no outage can move — be what ends the wait.
  *
+ * **An exit is read before anything else, and over the whole set.** It is the
+ * one fact that makes an unspent output unreachable, so it outranks `open`; and
+ * it is scanned across every output rather than in outpoint order, so which
+ * output happens to come first cannot change the answer.
+ *
  * Ask-the-indexer, don't-trust-local-state: read fresh on every poll, never
  * cached, the same posture {@link findLockupVtxos} already establishes.
  */
@@ -447,9 +490,9 @@ declare function readLockupFate(indexer: LockupSpendIndexer, input: {
  * {@link refundIfUnresolved}, which retries.
  *
  * **Swept outputs are refused, not attempted.** This is an OFFCHAIN spend, and
- * a swept output is no longer a live leaf: `canSpendOffchain` and
- * `canRecoverOnchain` are mutually exclusive by construction, so a recoverable
- * input cannot be spent this way whatever key signs it (see
+ * a swept output is no longer a live leaf: `canSpendOffchain` is false wherever
+ * `canRecoverOnchain` is true, so a recoverable input cannot be spent this way
+ * whatever key signs it (see
  * {@link LockupVtxo.recoverable}). Because every input lands in ONE aggregate
  * transaction, a single swept output would take the live ones down with it —
  * so the whole push is refused with {@link LockupNeedsRecoveryError} naming the
@@ -1162,7 +1205,9 @@ interface RfqSwapManagerDeps {
  *    `settled`; a lockup fully spent by anything else ends it `refunded`.
  *    Anything the indexer could not answer is `unknown`, which is NOT an
  *    answer: the pass carries on to the steps below, whose deadlines an indexer
- *    outage has no bearing on.
+ *    outage has no bearing on. `exited` — an output unilaterally taken onchain
+ *    — ends neither the swap nor the pass: it blocks the Arkade half below,
+ *    with the L1 half left running.
  * 2. **Drive the trader's claim.** On an onchain send that is the L1 fill — see
  *    {@link nextOnchainAction}. On a receive it is the lockup itself, and it
  *    ends the pass: that leg has no step 3.
@@ -1493,6 +1538,18 @@ declare class RfqSwapManager {
     private arm;
     private pollSwap;
     private runPass;
+    /**
+     * The lockup was unilaterally exited: its outputs sit onchain under the
+     * VHTLC script, where no offchain claim or refund can reach them.
+     *
+     * `needs_counterparty` rather than a terminal state, because the money still
+     * needs action and the swap can still end either way — an onchain claim can
+     * reveal the preimage, an onchain refund can return it — and that state is
+     * documented as re-checked every pass. It must be set from HERE and not from
+     * inside `driveArkadeRefund`, whose two `unblock` calls would lift it again
+     * on the very next pass.
+     */
+    private blockExitedLockup;
     /**
      * The receive leg's whole state machine: claim the solver-funded lockup
      * while the window is open, and recognise the shapes in which it can be

package/dist/{repository-BcZ9LXRP.d.ts → repository-Cw2EvvZG.d.ts}

@@ -1,6 +1,6 @@
 import { DiscoveredMarket } from '@arkade-os/solver-discovery';
 import { IWallet, ProvisionedKey, ProvisionedClaimSecret, RestArkProvider, RestIndexerProvider, VHTLC, Identity, IContractManager } from '@arkade-os/sdk';
-import { w as RfqStatus, x as RfqTransport, a as OnchainHtlc, e as ChainUtxo, C as ChainSource, s as OnchainHtlcPhase } from './rfq-C-aq5LDJ.js';
+import { x as RfqStatus, y as RfqTransport, a as OnchainHtlc, e as ChainUtxo, C as ChainSource, t as OnchainHtlcPhase } from './rfq-DglvHMNC.js';
 
 type AssetSwapStatus = "pending" | "cancelling" | "fulfilled" | "cancelled" | "recoverable" | "awaiting_fill" | "claimable" | "claimed" | "refunded_l1";
 /** The sentinel asset id for BTC itself, as opposed to a 68-hex asset id.
@@ -227,12 +227,15 @@ interface LockupVtxo {
      * It is still the trader's money and it is still visible, which is why
      * {@link findLockupVtxos} returns it. What it is not is refundable by
      * {@link pushRefundWithoutReceiver}: that builds an offchain Ark
-     * transaction, and the SDK's own predicates make the two states mutually
-     * exclusive — `canSpendOffchain` is false exactly when `canRecoverOnchain`
-     * is true (`wallet/vtxo.ts`), and the latter is documented as "must be
-     * recovered into a fresh batch rather than spent offchain". Holding the
-     * trader's `sender` key does not change that; a sweep removes the leaf from
-     * the live tree, not the signature from the trader.
+     * transaction, and the SDK's own predicates put the two states on opposite
+     * sides — `canSpendOffchain` is false whenever `canRecoverOnchain` is true
+     * (`wallet/vtxo.ts`), and the latter is documented as "must be recovered
+     * into a fresh batch rather than spent offchain". Holding the trader's
+     * `sender` key does not change that; a sweep removes the leaf from the live
+     * tree, not the signature from the trader.
+     *
+     * Opposite, but not exhaustive: an unrolled output satisfies neither, and
+     * {@link findLockupVtxos} drops those before they reach this type at all.
      *
      * `packages/boltz-swap` splits on exactly this fact rather than working
      * around it: `settleRefundWithoutReceiver` sends a live VTXO through an
@@ -321,6 +324,18 @@ declare class LockupNeedsRecoveryError extends Error {
  * That function refuses the recoverable ones by name rather than submitting a
  * spend the server must reject.
  *
+ * **Unrolled outputs are the one exception, and are dropped.** A unilaterally
+ * exited output lives onchain behind its CSV; no offchain spend of any leaf can
+ * reach it, and `LockupVtxo` carries no field to say so, so a caller could not
+ * tell it apart from a live one. Whether arkd returns such an output under
+ * `spendableOnly` is not determinable from here, so the exclusion is made
+ * defensively rather than assumed. It costs the two waiting callers nothing
+ * they wanted: `awaitLockupFunding` keeps waiting for a claimable lockup
+ * instead of publishing `P` into a spend that cannot land, and
+ * `refundIfUnresolved` reports `nothing_to_refund` instead of grinding a doomed
+ * push to its deadline. The manager reads the exit through
+ * {@link readLockupFate}, which queries unfiltered and reports it as `exited`.
+ *
  * This read — not the RFQ's reported state — is the authority on whether
  * there is anything left at the lockup.
  *
@@ -374,6 +389,29 @@ type LockupFate =
     fate: "returned";
     spends: readonly LockupSpend[];
 }
+/**
+ * At least one output was unilaterally exited: it sits onchain under the
+ * VHTLC script, where no offchain claim or refund can reach it.
+ *
+ * Not terminal, and not a loss. The money is still under the same script
+ * with the same leaves, so `completeUnroll` plus an onchain spend can still
+ * end the swap either way — which is why this outranks `open`: an output
+ * that is "still unspent" but unreachable is not a swap that is merely
+ * running.
+ *
+ * It outranks a verdict too, on a lockup where a sibling output was claimed
+ * or returned. That is the rule `open` already sets, not a new one: the
+ * unspent test short-circuits before any witness is read, so a partially
+ * resolved lockup has never reported `claimed`/`returned`. What changes is
+ * only that such a lockup now says why it is unresolved.
+ */
+ | {
+    fate: "exited";
+    outpoints: readonly {
+        txid: string;
+        vout: number;
+    }[];
+}
 /** Nothing was learned: no outputs visible, an output spent by nothing the
  * indexer names, a spend it could not produce, or a blob that would not
  * decode. Never an answer. */
@@ -409,6 +447,11 @@ type LockupFate =
  * response to `unknown` is the same as to `open`: keep watching, and let the
  * refund timelock — which no outage can move — be what ends the wait.
  *
+ * **An exit is read before anything else, and over the whole set.** It is the
+ * one fact that makes an unspent output unreachable, so it outranks `open`; and
+ * it is scanned across every output rather than in outpoint order, so which
+ * output happens to come first cannot change the answer.
+ *
  * Ask-the-indexer, don't-trust-local-state: read fresh on every poll, never
  * cached, the same posture {@link findLockupVtxos} already establishes.
  */
@@ -447,9 +490,9 @@ declare function readLockupFate(indexer: LockupSpendIndexer, input: {
  * {@link refundIfUnresolved}, which retries.
  *
  * **Swept outputs are refused, not attempted.** This is an OFFCHAIN spend, and
- * a swept output is no longer a live leaf: `canSpendOffchain` and
- * `canRecoverOnchain` are mutually exclusive by construction, so a recoverable
- * input cannot be spent this way whatever key signs it (see
+ * a swept output is no longer a live leaf: `canSpendOffchain` is false wherever
+ * `canRecoverOnchain` is true, so a recoverable input cannot be spent this way
+ * whatever key signs it (see
  * {@link LockupVtxo.recoverable}). Because every input lands in ONE aggregate
  * transaction, a single swept output would take the live ones down with it —
  * so the whole push is refused with {@link LockupNeedsRecoveryError} naming the
@@ -1162,7 +1205,9 @@ interface RfqSwapManagerDeps {
  *    `settled`; a lockup fully spent by anything else ends it `refunded`.
  *    Anything the indexer could not answer is `unknown`, which is NOT an
  *    answer: the pass carries on to the steps below, whose deadlines an indexer
- *    outage has no bearing on.
+ *    outage has no bearing on. `exited` — an output unilaterally taken onchain
+ *    — ends neither the swap nor the pass: it blocks the Arkade half below,
+ *    with the L1 half left running.
  * 2. **Drive the trader's claim.** On an onchain send that is the L1 fill — see
  *    {@link nextOnchainAction}. On a receive it is the lockup itself, and it
  *    ends the pass: that leg has no step 3.
@@ -1493,6 +1538,18 @@ declare class RfqSwapManager {
     private arm;
     private pollSwap;
     private runPass;
+    /**
+     * The lockup was unilaterally exited: its outputs sit onchain under the
+     * VHTLC script, where no offchain claim or refund can reach them.
+     *
+     * `needs_counterparty` rather than a terminal state, because the money still
+     * needs action and the swap can still end either way — an onchain claim can
+     * reveal the preimage, an onchain refund can return it — and that state is
+     * documented as re-checked every pass. It must be set from HERE and not from
+     * inside `driveArkadeRefund`, whose two `unblock` calls would lift it again
+     * on the very next pass.
+     */
+    private blockExitedLockup;
     /**
      * The receive leg's whole state machine: claim the solver-funded lockup
      * while the window is open, and recognise the shapes in which it can be

package/dist/{rfq-C-aq5LDJ.d.ts → rfq-DglvHMNC.d.cts}

@@ -9,6 +9,13 @@ declare const ONCHAIN_ORDER_MARGIN_SECONDS: number;
 declare const ONCHAIN_CLAIM_MARGIN_SECONDS: number;
 /** Bounds on the confirmation depth a quote may demand. */
 declare const MAX_MIN_CONFIRMATIONS = 6;
+/**
+ * BIP65's boundary between the two things an absolute locktime can mean.
+ * Below it consensus reads the value as a block height; at or above it, as a
+ * unix timestamp. 500,000,000 itself is 1985-07-05 and is a timestamp, so the
+ * comparison against it is strict.
+ */
+declare const LOCKTIME_THRESHOLD = 500000000;
 /** Conservative block interval for converting depths into wall-clock time. */
 declare const ONCHAIN_SECONDS_PER_BLOCK = 600;
 /**
@@ -239,7 +246,7 @@ declare const ONCHAIN_SEND_PAIR: string;
 /** On-board: a Bitcoin-L1 HTLC in, Arkade sats out. */
 declare const ONCHAIN_RECEIVE_PAIR: string;
 /** The closed refusal set. Treat any unknown reason as a generic decline. */
-type RfqRefusalReason = "unsupported_pair" | "unsupported_payload" | "amount_out_of_range" | "exposure_cap" | "invoice_expired" | "quote_conflict" | "pricing_unavailable";
+type RfqRefusalReason = "unsupported_pair" | "unsupported_payload" | "amount_out_of_range" | "exposure_cap" | "invoice_expired" | "quote_conflict" | "pricing_unavailable" | "rate_limited";
 /** Lifecycle vocabulary; states after which nothing more will happen. */
 declare const RFQ_TERMINAL_STATES: readonly ["settled", "refused", "expired", "refunded", "stuck"];
 /** A refusal from the solver, carrying its closed-set reason. */
@@ -480,12 +487,11 @@ interface InvoiceFacts {
  * throws while nothing is funded. `RfqSwapManager` re-registers as a backstop
  * for older records; a repeat write is a no-op.
  *
- * The `sender` key comes from the wallet — a fresh HD descriptor per call, or
- * the wallet's static key — and is returned as `senderPubkey` plus `secrets`.
- * `secrets` holds only a public descriptor; the signer re-derives from the
- * wallet, so nothing secret is at rest. Persist `secrets` with the record
- * anyway: it is how the refund signer is found again. `nonInteractiveRefund`
- * recovers the funds even without it — but it needs the SOLVER's active
+ * The `sender` key is the wallet's identity key, reused by {@link
+ * provisionRefundKey} — returned as `senderPubkey` plus `secrets`. `secrets`
+ * holds only a public descriptor; the signer re-derives from the wallet, so
+ * nothing secret is at rest. Persist `secrets` with the record anyway: it is
+ * how the refund signer is found again. `nonInteractiveRefund` recovers the funds even without it — but it needs the SOLVER's active
  * cooperation, not just infrastructure uptime.
  */
 declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
@@ -508,7 +514,8 @@ declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, tra
      * `lockup` (with `address`): without it the manager can only poll, and
      * cannot retire the row this call just wrote. */
     script: InstanceType<typeof VHTLC.ScriptV2>;
-    /** Where a failed swap refunds. */
+    /** Where a failed swap refunds — the same address `secrets.pkScript` was
+     * decoded from, so the quote and the covenant always name one script. */
     refundAddress: string;
     /** The VHTLC `sender` x-only key, bound into the covenant. Public. */
     senderPubkey: Uint8Array;
@@ -521,7 +528,9 @@ declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, tra
      * Returned so a consumer can persist the swap without re-deriving any of
      * it. Half of these are not on the quote: `serverPubkey` and `claimDelay`
      * come from this wallet's own `getInfo()`, `emulatorPubkey` from a
-     * per-network pin, `refundPkScript` from decoding an address.
+     * per-network pin, `refundPkScript` from `secrets` — decoded from the
+     * refund address at provisioning time, the same address this call returns
+     * as `refundAddress`.
      *
      * All public. Persisting them is optional: this call also registers the
      * lockup as a contract, and that row is where `rebuildRfqSwap` takes its
@@ -993,4 +1002,4 @@ declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, tr
     secrets: ProvisionedClaimSecret;
 }>;
 
-export { offerTermsFromQuote as $, ARKADE_ASSET as A, arkadeSwapRequest as B, type ChainSource as C, assertFundable as D, assertReceivable as E, awaitOnchainFill as F, buildHtlcClaim as G, type HtlcUtxo as H, type InvoiceFacts as I, buildHtlcRefund as J, claimOnchainFill as K, LIGHTNING_BTC as L, MAX_MIN_CONFIRMATIONS as M, classifyOnchainHtlc as N, type OnchainNetwork as O, deriveLightningReceive as P, deriveOnchainReceive as Q, RFQ_TERMINAL_STATES as R, SOLO_REFUND_HEADROOM_SECONDS as S, deriveOnchainSend as T, extractPreimage as U, httpTransport as V, lightningReceiveRequest as W, lightningSendRequest as X, lightningSendVtxoScript as Y, newPreimage as Z, newRfqId as _, type OnchainHtlc as a, onchainHtlcScript as a0, onchainReceiveRequest as a1, onchainSendRequest as a2, paymentHashOf as a3, receiveVtxoScript as a4, relayTransport as a5, requestLightningReceive as a6, requestLightningSend as a7, requestOnchainReceive as a8, requestOnchainSend as a9, rfqPair as aa, unilateralClaimDelay as ab, unilateralRefundDelay as ac, unilateralRefundWithoutReceiverDelay as ad, verifyLockupAddress as ae, verifyReceiveInvoice as af, type OnchainHtlcParams as b, ARKADE_BTC as c, AddressMismatch as d, type ChainUtxo as e, LIGHTNING_RECEIVE_PAIR as f, LIGHTNING_SEND_PAIR as g, type LightningReceiveTreeParams as h, type LightningSendTreeParams as i, MIN_CLAIM_WINDOW_SECONDS as j, MIN_HEADROOM_SECONDS as k, ONCHAIN_BTC as l, ONCHAIN_CLAIM_MARGIN_SECONDS as m, ONCHAIN_DUST_SATS as n, ONCHAIN_ORDER_MARGIN_SECONDS as o, ONCHAIN_RECEIVE_PAIR as p, ONCHAIN_SECONDS_PER_BLOCK as q, ONCHAIN_SEND_PAIR as r, type OnchainHtlcPhase as s, type RelaySocket as t, type RfqQuote as u, type RfqRefusalReason as v, type RfqStatus as w, type RfqTransport as x, SwapRefusal as y, arkadeAssetLeg as z };
+export { newRfqId as $, ARKADE_ASSET as A, arkadeAssetLeg as B, type ChainSource as C, arkadeSwapRequest as D, assertFundable as E, assertReceivable as F, awaitOnchainFill as G, type HtlcUtxo as H, type InvoiceFacts as I, buildHtlcClaim as J, buildHtlcRefund as K, LIGHTNING_BTC as L, MAX_MIN_CONFIRMATIONS as M, claimOnchainFill as N, type OnchainNetwork as O, classifyOnchainHtlc as P, deriveLightningReceive as Q, RFQ_TERMINAL_STATES as R, SOLO_REFUND_HEADROOM_SECONDS as S, deriveOnchainReceive as T, deriveOnchainSend as U, extractPreimage as V, httpTransport as W, lightningReceiveRequest as X, lightningSendRequest as Y, lightningSendVtxoScript as Z, newPreimage as _, type OnchainHtlc as a, offerTermsFromQuote as a0, onchainHtlcScript as a1, onchainReceiveRequest as a2, onchainSendRequest as a3, paymentHashOf as a4, receiveVtxoScript as a5, relayTransport as a6, requestLightningReceive as a7, requestLightningSend as a8, requestOnchainReceive as a9, requestOnchainSend as aa, rfqPair as ab, unilateralClaimDelay as ac, unilateralRefundDelay as ad, unilateralRefundWithoutReceiverDelay as ae, verifyLockupAddress as af, verifyReceiveInvoice as ag, type OnchainHtlcParams as b, ARKADE_BTC as c, AddressMismatch as d, type ChainUtxo as e, LIGHTNING_RECEIVE_PAIR as f, LIGHTNING_SEND_PAIR as g, LOCKTIME_THRESHOLD as h, type LightningReceiveTreeParams as i, type LightningSendTreeParams as j, MIN_CLAIM_WINDOW_SECONDS as k, MIN_HEADROOM_SECONDS as l, ONCHAIN_BTC as m, ONCHAIN_CLAIM_MARGIN_SECONDS as n, ONCHAIN_DUST_SATS as o, ONCHAIN_ORDER_MARGIN_SECONDS as p, ONCHAIN_RECEIVE_PAIR as q, ONCHAIN_SECONDS_PER_BLOCK as r, ONCHAIN_SEND_PAIR as s, type OnchainHtlcPhase as t, type RelaySocket as u, type RfqQuote as v, type RfqRefusalReason as w, type RfqStatus as x, type RfqTransport as y, SwapRefusal as z };

package/dist/{rfq-C-aq5LDJ.d.cts → rfq-DglvHMNC.d.ts}

@@ -9,6 +9,13 @@ declare const ONCHAIN_ORDER_MARGIN_SECONDS: number;
 declare const ONCHAIN_CLAIM_MARGIN_SECONDS: number;
 /** Bounds on the confirmation depth a quote may demand. */
 declare const MAX_MIN_CONFIRMATIONS = 6;
+/**
+ * BIP65's boundary between the two things an absolute locktime can mean.
+ * Below it consensus reads the value as a block height; at or above it, as a
+ * unix timestamp. 500,000,000 itself is 1985-07-05 and is a timestamp, so the
+ * comparison against it is strict.
+ */
+declare const LOCKTIME_THRESHOLD = 500000000;
 /** Conservative block interval for converting depths into wall-clock time. */
 declare const ONCHAIN_SECONDS_PER_BLOCK = 600;
 /**
@@ -239,7 +246,7 @@ declare const ONCHAIN_SEND_PAIR: string;
 /** On-board: a Bitcoin-L1 HTLC in, Arkade sats out. */
 declare const ONCHAIN_RECEIVE_PAIR: string;
 /** The closed refusal set. Treat any unknown reason as a generic decline. */
-type RfqRefusalReason = "unsupported_pair" | "unsupported_payload" | "amount_out_of_range" | "exposure_cap" | "invoice_expired" | "quote_conflict" | "pricing_unavailable";
+type RfqRefusalReason = "unsupported_pair" | "unsupported_payload" | "amount_out_of_range" | "exposure_cap" | "invoice_expired" | "quote_conflict" | "pricing_unavailable" | "rate_limited";
 /** Lifecycle vocabulary; states after which nothing more will happen. */
 declare const RFQ_TERMINAL_STATES: readonly ["settled", "refused", "expired", "refunded", "stuck"];
 /** A refusal from the solver, carrying its closed-set reason. */
@@ -480,12 +487,11 @@ interface InvoiceFacts {
  * throws while nothing is funded. `RfqSwapManager` re-registers as a backstop
  * for older records; a repeat write is a no-op.
  *
- * The `sender` key comes from the wallet — a fresh HD descriptor per call, or
- * the wallet's static key — and is returned as `senderPubkey` plus `secrets`.
- * `secrets` holds only a public descriptor; the signer re-derives from the
- * wallet, so nothing secret is at rest. Persist `secrets` with the record
- * anyway: it is how the refund signer is found again. `nonInteractiveRefund`
- * recovers the funds even without it — but it needs the SOLVER's active
+ * The `sender` key is the wallet's identity key, reused by {@link
+ * provisionRefundKey} — returned as `senderPubkey` plus `secrets`. `secrets`
+ * holds only a public descriptor; the signer re-derives from the wallet, so
+ * nothing secret is at rest. Persist `secrets` with the record anyway: it is
+ * how the refund signer is found again. `nonInteractiveRefund` recovers the funds even without it — but it needs the SOLVER's active
  * cooperation, not just infrastructure uptime.
  */
 declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, transport: RfqTransport, params: {
@@ -508,7 +514,8 @@ declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, tra
      * `lockup` (with `address`): without it the manager can only poll, and
      * cannot retire the row this call just wrote. */
     script: InstanceType<typeof VHTLC.ScriptV2>;
-    /** Where a failed swap refunds. */
+    /** Where a failed swap refunds — the same address `secrets.pkScript` was
+     * decoded from, so the quote and the covenant always name one script. */
     refundAddress: string;
     /** The VHTLC `sender` x-only key, bound into the covenant. Public. */
     senderPubkey: Uint8Array;
@@ -521,7 +528,9 @@ declare function requestLightningSend(wallet: IWallet, arkServerUrl: string, tra
      * Returned so a consumer can persist the swap without re-deriving any of
      * it. Half of these are not on the quote: `serverPubkey` and `claimDelay`
      * come from this wallet's own `getInfo()`, `emulatorPubkey` from a
-     * per-network pin, `refundPkScript` from decoding an address.
+     * per-network pin, `refundPkScript` from `secrets` — decoded from the
+     * refund address at provisioning time, the same address this call returns
+     * as `refundAddress`.
      *
      * All public. Persisting them is optional: this call also registers the
      * lockup as a contract, and that row is where `rebuildRfqSwap` takes its
@@ -993,4 +1002,4 @@ declare function requestOnchainReceive(wallet: IWallet, arkServerUrl: string, tr
     secrets: ProvisionedClaimSecret;
 }>;
 
-export { offerTermsFromQuote as $, ARKADE_ASSET as A, arkadeSwapRequest as B, type ChainSource as C, assertFundable as D, assertReceivable as E, awaitOnchainFill as F, buildHtlcClaim as G, type HtlcUtxo as H, type InvoiceFacts as I, buildHtlcRefund as J, claimOnchainFill as K, LIGHTNING_BTC as L, MAX_MIN_CONFIRMATIONS as M, classifyOnchainHtlc as N, type OnchainNetwork as O, deriveLightningReceive as P, deriveOnchainReceive as Q, RFQ_TERMINAL_STATES as R, SOLO_REFUND_HEADROOM_SECONDS as S, deriveOnchainSend as T, extractPreimage as U, httpTransport as V, lightningReceiveRequest as W, lightningSendRequest as X, lightningSendVtxoScript as Y, newPreimage as Z, newRfqId as _, type OnchainHtlc as a, onchainHtlcScript as a0, onchainReceiveRequest as a1, onchainSendRequest as a2, paymentHashOf as a3, receiveVtxoScript as a4, relayTransport as a5, requestLightningReceive as a6, requestLightningSend as a7, requestOnchainReceive as a8, requestOnchainSend as a9, rfqPair as aa, unilateralClaimDelay as ab, unilateralRefundDelay as ac, unilateralRefundWithoutReceiverDelay as ad, verifyLockupAddress as ae, verifyReceiveInvoice as af, type OnchainHtlcParams as b, ARKADE_BTC as c, AddressMismatch as d, type ChainUtxo as e, LIGHTNING_RECEIVE_PAIR as f, LIGHTNING_SEND_PAIR as g, type LightningReceiveTreeParams as h, type LightningSendTreeParams as i, MIN_CLAIM_WINDOW_SECONDS as j, MIN_HEADROOM_SECONDS as k, ONCHAIN_BTC as l, ONCHAIN_CLAIM_MARGIN_SECONDS as m, ONCHAIN_DUST_SATS as n, ONCHAIN_ORDER_MARGIN_SECONDS as o, ONCHAIN_RECEIVE_PAIR as p, ONCHAIN_SECONDS_PER_BLOCK as q, ONCHAIN_SEND_PAIR as r, type OnchainHtlcPhase as s, type RelaySocket as t, type RfqQuote as u, type RfqRefusalReason as v, type RfqStatus as w, type RfqTransport as x, SwapRefusal as y, arkadeAssetLeg as z };
+export { newRfqId as $, ARKADE_ASSET as A, arkadeAssetLeg as B, type ChainSource as C, arkadeSwapRequest as D, assertFundable as E, assertReceivable as F, awaitOnchainFill as G, type HtlcUtxo as H, type InvoiceFacts as I, buildHtlcClaim as J, buildHtlcRefund as K, LIGHTNING_BTC as L, MAX_MIN_CONFIRMATIONS as M, claimOnchainFill as N, type OnchainNetwork as O, classifyOnchainHtlc as P, deriveLightningReceive as Q, RFQ_TERMINAL_STATES as R, SOLO_REFUND_HEADROOM_SECONDS as S, deriveOnchainReceive as T, deriveOnchainSend as U, extractPreimage as V, httpTransport as W, lightningReceiveRequest as X, lightningSendRequest as Y, lightningSendVtxoScript as Z, newPreimage as _, type OnchainHtlc as a, offerTermsFromQuote as a0, onchainHtlcScript as a1, onchainReceiveRequest as a2, onchainSendRequest as a3, paymentHashOf as a4, receiveVtxoScript as a5, relayTransport as a6, requestLightningReceive as a7, requestLightningSend as a8, requestOnchainReceive as a9, requestOnchainSend as aa, rfqPair as ab, unilateralClaimDelay as ac, unilateralRefundDelay as ad, unilateralRefundWithoutReceiverDelay as ae, verifyLockupAddress as af, verifyReceiveInvoice as ag, type OnchainHtlcParams as b, ARKADE_BTC as c, AddressMismatch as d, type ChainUtxo as e, LIGHTNING_RECEIVE_PAIR as f, LIGHTNING_SEND_PAIR as g, LOCKTIME_THRESHOLD as h, type LightningReceiveTreeParams as i, type LightningSendTreeParams as j, MIN_CLAIM_WINDOW_SECONDS as k, MIN_HEADROOM_SECONDS as l, ONCHAIN_BTC as m, ONCHAIN_CLAIM_MARGIN_SECONDS as n, ONCHAIN_DUST_SATS as o, ONCHAIN_ORDER_MARGIN_SECONDS as p, ONCHAIN_RECEIVE_PAIR as q, ONCHAIN_SECONDS_PER_BLOCK as r, ONCHAIN_SEND_PAIR as s, type OnchainHtlcPhase as t, type RelaySocket as u, type RfqQuote as v, type RfqRefusalReason as w, type RfqStatus as x, type RfqTransport as y, SwapRefusal as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/swap",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "description": "Client-side Arkade Intents asset swaps: discover markets, quote, create/track/cancel offers, restore from chain.",
   "repository": {
@@ -65,11 +65,12 @@
   "license": "MIT",
   "dependencies": {
     "@arkade-os/solver-discovery": "0.2.3",
+    "@noble/ciphers": "2.1.1",
     "@noble/curves": "2.0.1",
     "@noble/hashes": "2.0.1",
     "@scure/base": "2.0.0",
     "@scure/btc-signer": "2.0.1",
-    "@arkade-os/sdk": "0.4.65"
+    "@arkade-os/sdk": "0.4.67"
   },
   "peerDependencies": {
     "nostr-tools": "^2.12.0"
@@ -90,8 +91,8 @@
   "scripts": {
     "build": "tsup src/index.ts src/nostr.ts src/repositories/sqlite/index.ts src/repositories/realm/index.ts --format esm,cjs --dts --clean",
     "typecheck": "tsc --noEmit",
-    "format": "prettier --write src test",
-    "lint": "prettier --check src test",
+    "format": "biome format --write src test",
+    "lint": "biome format src test",
     "test": "vitest run --exclude test/e2e",
     "test:unit": "vitest run --exclude test/e2e",
     "test:integration": "vitest run test/e2e/** --exclude test/e2e/rfq*.test.ts",