@arkade-os/swap 0.0.10 → 0.0.12

package/dist/index.js

@@ -2,6 +2,7 @@ import {
   ARKADE_ASSET,
   ARKADE_BTC,
   AddressMismatch,
+  L1_NETWORKS,
   LIGHTNING_BTC,
   LIGHTNING_RECEIVE_PAIR,
   LIGHTNING_SEND_PAIR,
@@ -38,6 +39,7 @@ import {
   deriveOnchainSend,
   extractPreimage,
   httpTransport,
+  l1ScriptForAddress,
   lightningReceiveRequest,
   lightningSendRequest,
   lightningSendVtxoScript,
@@ -63,7 +65,7 @@ import {
   unilateralRefundWithoutReceiverDelay,
   verifyLockupAddress,
   verifyReceiveInvoice
-} from "./chunk-5NPYNQ5V.js";
+} from "./chunk-XXWOODUE.js";
 import {
   InMemoryAssetSwapRepository,
   marketsCacheKey
@@ -329,12 +331,30 @@ var swapPrograms = {
   wantAsset: arkade.parseArtifact(swap_want_asset_program_default),
   wantBtc: 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,
@@ -344,7 +364,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,
@@ -365,9 +386,27 @@ var FIELDS = {
   makerPkScript: { tag: 5, width: 34 },
   makerPublicKey: { tag: 7, width: 32 },
   emulatorPubkey: { tag: 8, width: 32 },
-  offerAsset: { tag: 11, width: void 0 }
+  ratioNum: { tag: 9, width: 8 },
+  ratioDen: { tag: 10, width: 8 },
+  offerAsset: { tag: 11, width: void 0 },
+  exitTimelock: { tag: 12, width: 9 }
 };
+var EXIT_TYPES = ["blocks", "seconds"];
 var NAMES = Object.fromEntries(Object.entries(FIELDS).map(([k, f]) => [f.tag, k]));
+function u64(name, value) {
+  if (value < BigInt(0) || value >> BigInt(64) > BigInt(0)) {
+    throw new Error(`${name} does not fit the offer wire format (u64)`);
+  }
+  const out = new Uint8Array(FIELDS.wantAmount.width);
+  new DataView(out.buffer).setBigUint64(0, value, false);
+  return out;
+}
+var readU64 = (value) => new DataView(value.buffer, value.byteOffset).getBigUint64(0, false);
+var setRatio = (name, value) => {
+  if (value === void 0 || value === BigInt(0)) return void 0;
+  if (value < BigInt(0)) throw new Error(`${name} does not fit the offer wire format (u64)`);
+  return value;
+};
 function tlv(type, value) {
   if (value.length > 65535) throw new Error("TLV value exceeds the u16 length field");
   return concatBytes(Uint8Array.of(type, value.length >> 8 & 255, value.length & 255), value);
@@ -386,24 +425,45 @@ function encodeOffer(offer) {
       throw new Error(`${name} must be ${FIELDS[name].width} bytes`);
     }
   }
-  if (offer.wantAmount < BigInt(0) || offer.wantAmount >> BigInt(64) > BigInt(0)) {
-    throw new Error("wantAmount does not fit the offer wire format (u64)");
+  const ratioNum = setRatio("ratioNum", offer.ratioNum);
+  const ratioDen = setRatio("ratioDen", offer.ratioDen);
+  if (ratioNum === void 0 !== (ratioDen === void 0)) {
+    throw new Error("offer must carry both ratioNum and ratioDen, or neither");
   }
-  const amount = new Uint8Array(FIELDS.wantAmount.width);
-  new DataView(amount.buffer).setBigUint64(0, offer.wantAmount, false);
   const recs = [
     tlv(FIELDS.swapPkScript.tag, offer.swapPkScript),
-    tlv(FIELDS.wantAmount.tag, amount)
+    tlv(FIELDS.wantAmount.tag, u64("wantAmount", offer.wantAmount))
   ];
   if (offer.wantAsset) recs.push(tlv(FIELDS.wantAsset.tag, offer.wantAsset.serialize()));
+  if (ratioNum !== void 0) recs.push(tlv(FIELDS.ratioNum.tag, u64("ratioNum", ratioNum)));
+  if (ratioDen !== void 0) recs.push(tlv(FIELDS.ratioDen.tag, u64("ratioDen", ratioDen)));
   if (offer.offerAsset) recs.push(tlv(FIELDS.offerAsset.tag, offer.offerAsset.serialize()));
   recs.push(
     tlv(FIELDS.makerPkScript.tag, offer.makerPkScript),
     tlv(FIELDS.makerPublicKey.tag, offer.makerPublicKey),
     tlv(FIELDS.emulatorPubkey.tag, offer.emulatorPubkey)
   );
+  if (offer.exitDelay) recs.push(tlv(FIELDS.exitTimelock.tag, encodeExitDelay(offer.exitDelay)));
   return concatBytes(...recs);
 }
+function encodeExitDelay(exit) {
+  return concatBytes(
+    Uint8Array.of(EXIT_TYPES.indexOf(assertExitDelay(exit).type)),
+    u64("exitDelay", exit.value)
+  );
+}
+function assertExitDelay(exit) {
+  if (EXIT_TYPES.indexOf(exit.type) < 0) {
+    throw new Error(`unknown exitDelay locktime type: ${exit.type}`);
+  }
+  if (exit.value <= BigInt(0)) {
+    throw new Error("exitDelay must be a positive relative locktime");
+  }
+  if (exit.value >> BigInt(32) > BigInt(0)) {
+    throw new Error("exitDelay does not fit the locktime field (u32)");
+  }
+  return exit;
+}
 function decodeOffer(data) {
   const fields = {};
   let off = 0;
@@ -423,6 +483,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;
@@ -434,16 +500,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: asset.AssetId.fromBytes(fields.wantAsset) },
     ...fields.offerAsset && { offerAsset: 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) {
@@ -469,6 +555,14 @@ async function registerOfferContract(wallet, arkServerUrl, network, binding, ser
   });
   await promoteOfferContract(contractManager, hex2.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)");
@@ -489,7 +583,11 @@ async function createOffer(wallet, arkServerUrl, params) {
     offerAsset: params.offerAsset,
     makerPkScript: ArkAddress.decode(makerAddress).pkScript,
     makerPublicKey,
-    emulatorPubkey: emuKey
+    emulatorPubkey: emuKey,
+    // checked HERE, before the covenant is derived and registered below:
+    // deferring it to `encodeOffer` leaves a registered contract behind for
+    // an offer that then fails to encode. @see assertExitDelay
+    exitDelay: params.noExit ? void 0 : params.exitDelay ? assertExitDelay(params.exitDelay) : serverExitDelay(info.unilateralExitDelay)
   };
   const script = offerVtxoScript(binding, serverPubKey);
   const offer = { ...binding, swapPkScript: script.pkScript };
@@ -965,7 +1063,8 @@ function onchainSendProfile(result) {
     htlcLocktime: result.htlcParams.refundLocktime,
     network: result.l1Network,
     htlcAddress: result.htlc.address,
-    minConfirmations: result.minConfirmations
+    minConfirmations: result.minConfirmations,
+    payoutPkScript: hex3.encode(result.payoutPkScript)
   };
 }
 var OnchainSendCorridor = {
@@ -1014,6 +1113,9 @@ var OnchainSendCorridor = {
       paymentHash,
       htlc,
       minConfirmations: profile.minConfirmations,
+      // Optional here, required at the write: throwing on an older
+      // record would strand the refund it is still owed.
+      ...profile.payoutPkScript ? { payoutPkScript: hex3.decode(profile.payoutPkScript) } : {},
       ...profile.funding ? { funding: profile.funding } : {},
       ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {}
     };
@@ -1178,7 +1280,9 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
     const script = offerVtxoScript(offer, serverPubkey);
     if (hex5.encode(script.pkScript) !== hex5.encode(offer.swapPkScript)) return "indeterminate";
     leaves = {
-      cancel: script.functionByName("cancel")?.leafScript,
+      // both routes that hand the deposit back; `exit` is absent on an
+      // offer that carries no exit closure, and drops out here
+      returned: ["cancel", "exit"].map((name) => script.functionByName(name)?.leafScript).filter((leaf) => leaf !== void 0),
       fulfill: script.functionByName("fulfill")?.leafScript
     };
   } catch {
@@ -1190,7 +1294,7 @@ function classifySpend(offer, serverPubkey, spendTx, deposit) {
     if (hex5.encode(input.txid) !== deposit.txid) continue;
     for (const leaf of input.tapLeafScript ?? []) {
       const spent = hex5.encode(scriptFromTapLeafScript(leaf));
-      if (leaves.cancel && spent === hex5.encode(leaves.cancel)) return "cancelled";
+      if (leaves.returned.some((back) => spent === hex5.encode(back))) return "cancelled";
       if (leaves.fulfill && spent === hex5.encode(leaves.fulfill)) return "fulfilled";
     }
   }
@@ -1392,8 +1496,294 @@ async function watchOfferSwaps({
   };
 }
 
-// src/claim.ts
+// src/chainSource.ts
+import * as btc from "@scure/btc-signer";
+import { hex as hex7 } from "@scure/base";
+var addressOf = (pkScript, network) => btc.Address(L1_NETWORKS[network]).encode(btc.OutScript.decode(pkScript));
+var chainSourceFrom = (provider, network) => {
+  const spenderFromHistory = async (txid, vout, pkScript) => {
+    const txs = await provider.getTransactions(addressOf(pkScript, network));
+    return txs.find((tx) => tx.vin?.some((i) => i.txid === txid && i.vout === vout))?.txid;
+  };
+  return {
+    async getScriptUtxos(pkScript) {
+      const address = addressOf(pkScript, network);
+      const [coins, tip] = await Promise.all([
+        provider.getCoins(address),
+        provider.getChainTip()
+      ]);
+      return coins.map((coin) => ({
+        txid: coin.txid,
+        vout: coin.vout,
+        amount: BigInt(coin.value),
+        // Zero, not one: calling a mempool output "1 deep" would let a
+        // 1-confirmation policy claim against a replaceable transaction.
+        confirmations: coin.status.confirmed && typeof coin.status.block_height === "number" ? Math.max(0, tip.height - coin.status.block_height + 1) : 0
+      }));
+    },
+    async getSpendingTx(txid, vout, pkScript) {
+      const outspends = await provider.getTxOutspends(txid);
+      const outspend = outspends[vout];
+      if (!outspend?.spent) return null;
+      const spender = outspend.txid || await spenderFromHistory(txid, vout, pkScript);
+      if (!spender) return null;
+      const raw = await provider.getRawTransaction(spender);
+      return { txHex: hex7.encode(raw) };
+    },
+    broadcast(txHex) {
+      return provider.broadcastTransaction(txHex);
+    },
+    async getMtp() {
+      return (await provider.getChainTip()).time;
+    }
+  };
+};
+
+// src/payment/rendezvous.ts
+import { selectMarkets, sideLimits as sideLimits2 } from "@arkade-os/solver-discovery";
 import { hex as hex8 } from "@scure/base";
+var XONLY_HEX = /^[0-9a-f]{64}$/;
+var rendezvousOf = (market, pinned) => {
+  const transports = { nostr: { relays: market.transports?.nostr?.relays ?? [] } };
+  if (!market.discovery_pubkey || !transports.nostr.relays.length) return void 0;
+  const advertised = market.emulator_pubkey;
+  const emulatorPubkey = advertised === void 0 || advertised === null || advertised === "" ? pinned : typeof advertised === "string" && XONLY_HEX.test(advertised) ? advertised : void 0;
+  if (!emulatorPubkey) return void 0;
+  if (pinned && emulatorPubkey !== pinned) return void 0;
+  const bounds = sideLimits2(market, "quote");
+  if (!bounds) return void 0;
+  return {
+    solverPubkey: market.discovery_pubkey,
+    transports,
+    minSats: Number(bounds.min),
+    maxSats: Number(bounds.max)
+  };
+};
+var solverRendezvous = (markets, payoutCorridor, amountSats, fallbackEmulatorPubkey) => {
+  const encoded = fallbackEmulatorPubkey ? hex8.encode(fallbackEmulatorPubkey) : void 0;
+  if (encoded !== void 0 && !XONLY_HEX.test(encoded)) return void 0;
+  const pinned = encoded;
+  const candidates = selectMarkets(markets, {
+    baseId: BTC_ASSET_ID,
+    quoteId: BTC_ASSET_ID,
+    baseCorridor: "arkade",
+    quoteCorridor: payoutCorridor
+  });
+  for (const market of candidates) {
+    const rendezvous = rendezvousOf(market, pinned);
+    if (!rendezvous) continue;
+    if (amountSats >= rendezvous.minSats && amountSats <= rendezvous.maxSats) {
+      return rendezvous;
+    }
+  }
+  return void 0;
+};
+
+// src/payment/solverOnchain.ts
+import { btcTarget, makeHandle, resolveSendAmount, tryResolveSendAmount } from "@arkade-os/sdk";
+var SOLVER_ONCHAIN_RAIL = "solver-onchain";
+var solverOnchainRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "onchain", amountSats, fallbackEmulatorPubkey);
+function solverOnchainRail(deps) {
+  const rendezvousFor = async (amount) => {
+    if (amount === void 0) return void 0;
+    const markets = await deps.discover();
+    return solverOnchainRendezvous(markets, amount, deps.fallbackEmulatorPubkey);
+  };
+  return {
+    id: SOLVER_ONCHAIN_RAIL,
+    match: (req) => btcTarget(req.raw) !== void 0,
+    available: async (req) => {
+      const address = btcTarget(req.raw);
+      if (!address) return false;
+      try {
+        l1ScriptForAddress(address, deps.l1Network);
+      } catch {
+        return false;
+      }
+      const amount = tryResolveSendAmount(req.raw, req.amount);
+      if (amount === void 0) return false;
+      return await rendezvousFor(amount) !== void 0;
+    },
+    quote: async (req, ctx) => {
+      const address = btcTarget(req.raw);
+      const amount = resolveSendAmount(SOLVER_ONCHAIN_RAIL, req.raw, req.amount);
+      const payoutPkScript = l1ScriptForAddress(address, deps.l1Network);
+      const rendezvous = await rendezvousFor(amount);
+      if (!rendezvous) {
+        throw new Error(
+          `${SOLVER_ONCHAIN_RAIL}: no solver serves arkade:BTC -> onchain:BTC at ${amount} sats`
+        );
+      }
+      const negotiated = await deps.connect(
+        rendezvous,
+        (transport) => requestOnchainSend(ctx.wallet, deps.arkServerUrl, transport, {
+          amount,
+          amountSide: "to",
+          payoutPubkey: deps.payoutPubkey,
+          ...deps.emulatorPubkey ? { emulatorPubkey: deps.emulatorPubkey } : {}
+        })
+      );
+      if (negotiated.l1Network !== deps.l1Network) {
+        throw new Error(
+          `${SOLVER_ONCHAIN_RAIL}: rail built for ${deps.l1Network} but the swap was negotiated on ${negotiated.l1Network}`
+        );
+      }
+      const swap = { ...negotiated, rendezvous, payoutPkScript };
+      return {
+        railId: SOLVER_ONCHAIN_RAIL,
+        amount,
+        fee: swap.fundAmount - amount,
+        total: swap.fundAmount,
+        meta: {
+          rfqId: swap.rfqId,
+          validUntil: swap.quote.valid_until,
+          htlcAddress: swap.htlc.address,
+          minConfirmations: swap.minConfirmations,
+          solverPubkey: rendezvous.solverPubkey,
+          // The claim tx's fee comes out of the HTLC output at a rate
+          // not knowable now, so `amount` is the payout, not the net.
+          claimFeeDeductedFromPayout: true
+        },
+        send: async () => makeHandle(SOLVER_ONCHAIN_RAIL, async (emit) => {
+          assertFundable({
+            quote: swap.quote,
+            now: Math.floor(Date.now() / 1e3),
+            onchain: {
+              htlcLocktime: swap.htlcParams.refundLocktime,
+              minConfirmations: swap.minConfirmations,
+              direction: "send"
+            }
+          });
+          await deps.persist(swap);
+          await ctx.wallet.send({
+            address: swap.address,
+            amount: swap.fundAmount
+          });
+          emit({ status: "sent" });
+          const result = { railId: SOLVER_ONCHAIN_RAIL, swapId: swap.rfqId };
+          if (!deps.awaitSettlement) return result;
+          let txid;
+          try {
+            ({ txid } = await deps.awaitSettlement(swap));
+          } catch (e) {
+            console.warn(
+              `${SOLVER_ONCHAIN_RAIL}: settlement watch failed; the payment is sent`,
+              e
+            );
+            return result;
+          }
+          const settled = { ...result, txid };
+          emit({ status: "settled", result: settled });
+          return settled;
+        })
+      };
+    }
+  };
+}
+
+// src/payment/solverLightning.ts
+import { invoiceTarget, makeHandle as makeHandle2 } from "@arkade-os/sdk";
+var SOLVER_LIGHTNING_RAIL = "solver-lightning";
+var factsOf = (raw, decode, now) => {
+  const invoice = invoiceTarget(raw);
+  if (!invoice) return void 0;
+  let facts;
+  try {
+    facts = decode(invoice);
+  } catch {
+    return void 0;
+  }
+  if (!Number.isInteger(facts.amountSats) || facts.amountSats <= 0) return void 0;
+  if (facts.expiresAt <= now) return void 0;
+  return facts;
+};
+var solverLightningRendezvous = (markets, amountSats, fallbackEmulatorPubkey) => solverRendezvous(markets, "lightning", amountSats, fallbackEmulatorPubkey);
+function solverLightningRail(deps) {
+  const rendezvousFor = async (amountSats) => solverLightningRendezvous(await deps.discover(), amountSats, deps.fallbackEmulatorPubkey);
+  return {
+    id: SOLVER_LIGHTNING_RAIL,
+    match: (req) => invoiceTarget(req.raw) !== void 0,
+    available: async (req) => {
+      const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
+      if (!facts) return false;
+      if (req.amount !== void 0 && req.amount !== facts.amountSats) return false;
+      return await rendezvousFor(facts.amountSats) !== void 0;
+    },
+    quote: async (req, ctx) => {
+      const facts = factsOf(req.raw, deps.decodeInvoice, Math.floor(Date.now() / 1e3));
+      if (!facts) {
+        throw new Error(
+          `${SOLVER_LIGHTNING_RAIL}: the request carries no payable BOLT11 invoice (amountless, expired, or undecodable)`
+        );
+      }
+      if (req.amount !== void 0 && req.amount !== facts.amountSats) {
+        throw new Error(
+          `${SOLVER_LIGHTNING_RAIL}: the request names ${req.amount} sats but the invoice is for ${facts.amountSats} \u2014 the payee is paid the invoice`
+        );
+      }
+      const rendezvous = await rendezvousFor(facts.amountSats);
+      if (!rendezvous) {
+        throw new Error(
+          `${SOLVER_LIGHTNING_RAIL}: no solver serves arkade:BTC -> lightning:BTC at ${facts.amountSats} sats`
+        );
+      }
+      const negotiated = await deps.connect(
+        rendezvous,
+        (transport) => requestLightningSend(ctx.wallet, deps.arkServerUrl, transport, {
+          invoice: facts,
+          ...deps.emulatorPubkey ? { emulatorPubkey: deps.emulatorPubkey } : {}
+        })
+      );
+      const swap = { ...negotiated, invoice: facts, rendezvous };
+      return {
+        railId: SOLVER_LIGHTNING_RAIL,
+        // `requestLightningSend` refuses a quote that reprices the
+        // invoice, so the spread is a fee on top.
+        amount: facts.amountSats,
+        fee: swap.fundAmount - facts.amountSats,
+        total: swap.fundAmount,
+        meta: {
+          rfqId: swap.rfqId,
+          validUntil: swap.quote.valid_until,
+          paymentHash: facts.paymentHash,
+          invoiceExpiresAt: facts.expiresAt,
+          solverPubkey: rendezvous.solverPubkey
+        },
+        send: async () => makeHandle2(SOLVER_LIGHTNING_RAIL, async (emit) => {
+          assertFundable({
+            quote: swap.quote,
+            invoiceExpiresAt: facts.expiresAt,
+            now: Math.floor(Date.now() / 1e3)
+          });
+          await deps.persist(swap);
+          await ctx.wallet.send({
+            address: swap.address,
+            amount: swap.fundAmount
+          });
+          emit({ status: "sent" });
+          const result = { railId: SOLVER_LIGHTNING_RAIL, swapId: swap.rfqId };
+          if (!deps.awaitSettlement) return result;
+          let preimage;
+          try {
+            ({ preimage } = await deps.awaitSettlement(swap));
+          } catch (e) {
+            console.warn(
+              `${SOLVER_LIGHTNING_RAIL}: settlement watch failed; the payment is sent`,
+              e
+            );
+            return result;
+          }
+          const settled = { ...result, ...preimage !== void 0 && { preimage } };
+          emit({ status: "settled", result: settled });
+          return settled;
+        })
+      };
+    }
+  };
+}
+
+// src/claim.ts
+import { hex as hex10 } from "@scure/base";
 import { ripemd160 } from "@noble/hashes/legacy.js";
 import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 import {
@@ -1403,7 +1793,7 @@ import {
 } from "@arkade-os/sdk";
 
 // src/refund.ts
-import { base64 as base643, hex as hex7 } from "@scure/base";
+import { base64 as base643, hex as hex9 } from "@scure/base";
 import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import {
   CSVMultisigTapscript,
@@ -1461,7 +1851,7 @@ var LockupNeedsRecoveryError = class extends Error {
   }
 };
 async function findLockupVtxos(indexer, swapPkScript) {
-  const scripts = [hex7.encode(swapPkScript)];
+  const scripts = [hex9.encode(swapPkScript)];
   const [spendable, recoverable] = await Promise.all([
     indexer.getVtxos({ scripts, spendableOnly: true }),
     indexer.getVtxos({ scripts, recoverableOnly: true })
@@ -1487,13 +1877,13 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => hex7.encode(sha2562(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => hex9.encode(sha2562(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
   ...getArkPsbtFields(tx, inputIndex, ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
 ];
 async function readLockupFate(indexer, input) {
-  const { vtxos } = await indexer.getVtxos({ scripts: [hex7.encode(input.swapPkScript)] });
+  const { vtxos } = await indexer.getVtxos({ scripts: [hex9.encode(input.swapPkScript)] });
   const all = vtxos ?? [];
   if (all.length === 0) return { fate: "unknown" };
   const exited = all.filter((vtxo) => vtxo.isUnrolled && !hasTerminalSpend(vtxo));
@@ -1528,7 +1918,7 @@ async function readLockupFate(indexer, input) {
     for (let i = 0; i < tx.inputsLength; i++) {
       const spent = tx.getInput(i);
       if (!spent.txid) continue;
-      const txid = hex7.encode(spent.txid);
+      const txid = hex9.encode(spent.txid);
       if (!all.some((vtxo) => vtxo.txid === txid && vtxo.vout === spent.index)) continue;
       for (const candidate of candidateWitnessItems(tx, i)) {
         if (hashesTo(candidate, input.paymentHash)) {
@@ -1548,16 +1938,16 @@ 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();
   let serverUnrollScript;
   try {
-    serverUnrollScript = CSVMultisigTapscript.decode(hex7.decode(info.checkpointTapscript));
+    serverUnrollScript = CSVMultisigTapscript.decode(hex9.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
@@ -1603,6 +1993,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 {
@@ -1668,13 +2073,13 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (hex8.encode(ripemd160(sha2563(input.preimage))) !== hex8.encode(committed)) {
+  if (hex10.encode(ripemd160(sha2563(input.preimage))) !== hex10.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = CSVMultisigTapscript2.decode(hex8.decode(info.checkpointTapscript));
+    serverUnrollScript = CSVMultisigTapscript2.decode(hex10.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
@@ -1793,7 +2198,7 @@ function arkadeRefunder(deps) {
 }
 
 // src/swapManager.ts
-import { hex as hex9 } from "@scure/base";
+import { hex as hex11 } from "@scure/base";
 function nextOnchainAction(input) {
   switch (input.phase.phase) {
     case "unfunded":
@@ -2241,7 +2646,7 @@ var RfqSwapManager = class {
   // ── internals ────────────────────────────────────────────────────────────
   track(swap) {
     this.monitored.set(swap.rfqId, swap);
-    this.byLockupScript.set(hex9.encode(swap.lockupPkScript), swap);
+    this.byLockupScript.set(hex11.encode(swap.lockupPkScript), swap);
   }
   /** Drops the swap from BOTH indexes. The event index is the one that stops
    * a late event finding a swap that is gone; `pollSwap`'s own
@@ -2250,7 +2655,7 @@ var RfqSwapManager = class {
    * them from silently re-driving a cancelled swap. */
   untrack(rfqId) {
     const swap = this.monitored.get(rfqId);
-    if (swap) this.byLockupScript.delete(hex9.encode(swap.lockupPkScript));
+    if (swap) this.byLockupScript.delete(hex11.encode(swap.lockupPkScript));
     this.monitored.delete(rfqId);
     this.refundRefused.delete(rfqId);
     this.lastClaimError.delete(rfqId);
@@ -2312,7 +2717,7 @@ var RfqSwapManager = class {
     if (!lockup) {
       try {
         const [existing] = await contracts.getContracts({
-          script: hex9.encode(swap.lockupPkScript)
+          script: hex11.encode(swap.lockupPkScript)
         });
         if (existing) {
           this.registered.set(swap.rfqId, true);
@@ -2331,13 +2736,13 @@ var RfqSwapManager = class {
       );
       return;
     }
-    const script = hex9.encode(lockup.script.pkScript);
-    if (script !== hex9.encode(swap.lockupPkScript)) {
+    const script = hex11.encode(lockup.script.pkScript);
+    if (script !== hex11.encode(swap.lockupPkScript)) {
       this.registered.set(swap.rfqId, false);
       this.emitFailed(
         swap,
         new Error(
-          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${hex9.encode(swap.lockupPkScript)}`
+          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${hex11.encode(swap.lockupPkScript)}`
         )
       );
       return;
@@ -2356,7 +2761,7 @@ var RfqSwapManager = class {
    * script for its whole life. Best-effort — the swap is over either way. */
   retireContract(swap) {
     if (!this.deps.contracts || !this.registered.get(swap.rfqId)) return;
-    void this.deps.contracts.setContractWatchState(hex9.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
+    void this.deps.contracts.setContractWatchState(hex11.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
   }
   arm() {
     if (!this.running) return;
@@ -2832,7 +3237,7 @@ var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 import {
   ArkAddress as ArkAddress4
 } from "@arkade-os/sdk";
-import { hex as hex10 } from "@scure/base";
+import { hex as hex12 } from "@scure/base";
 var LABELS = {
   lightning_send: "Lightning send",
   lightning_receive: "Lightning receive",
@@ -2907,7 +3312,7 @@ async function activityInputOf(record, indexer) {
 async function lockupTxids(indexer, record, wantFunding) {
   let script;
   try {
-    script = hex10.encode(ArkAddress4.decode(record.lockupAddress).pkScript);
+    script = hex12.encode(ArkAddress4.decode(record.lockupAddress).pkScript);
   } catch {
     return [];
   }
@@ -2960,6 +3365,8 @@ export {
   RfqSwapManager,
   RfqSwapOriginRequired,
   SOLO_REFUND_HEADROOM_SECONDS,
+  SOLVER_LIGHTNING_RAIL,
+  SOLVER_ONCHAIN_RAIL,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
@@ -2976,6 +3383,7 @@ export {
   buildHtlcClaim,
   buildHtlcRefund,
   cancelOffer,
+  chainSourceFrom,
   claimOnchainFill,
   claimReceiveLockup,
   classifyDepositSpend,
@@ -2997,6 +3405,7 @@ export {
   httpTransport,
   isRfqSwapTerminal,
   isRfqTerminal,
+  l1ScriptForAddress,
   lightningReceiveRequest,
   lightningSendRequest,
   lightningSendVtxoScript,
@@ -3036,6 +3445,11 @@ export {
   sealClaimPacket,
   senderIdentityForSwapRecord,
   shouldRetainRfqSwap,
+  solverLightningRail,
+  solverLightningRendezvous,
+  solverOnchainRail,
+  solverOnchainRendezvous,
+  solverRendezvous,
   spendTxidsOf,
   spendUpdate,
   swapActivityResolver,