@arkade-os/swap 0.0.11 → 0.0.13

package/dist/index.cjs

@@ -34,6 +34,8 @@ __export(index_exports, {
   ARKADE_BTC: () => ARKADE_BTC,
   AddressMismatch: () => AddressMismatch,
   BTC_ASSET_ID: () => BTC_ASSET_ID,
+  CROSS_ASSET_RAIL: () => CROSS_ASSET_RAIL,
+  CovclaimdRevealError: () => CovclaimdRevealError,
   InMemoryAssetSwapRepository: () => InMemoryAssetSwapRepository,
   IndexedDbAssetSwapRepository: () => IndexedDbAssetSwapRepository,
   LIGHTNING_BTC: () => LIGHTNING_BTC,
@@ -66,6 +68,8 @@ __export(index_exports, {
   RfqSwapManager: () => RfqSwapManager,
   RfqSwapOriginRequired: () => RfqSwapOriginRequired,
   SOLO_REFUND_HEADROOM_SECONDS: () => SOLO_REFUND_HEADROOM_SECONDS,
+  SOLVER_LIGHTNING_RAIL: () => SOLVER_LIGHTNING_RAIL,
+  SOLVER_ONCHAIN_RAIL: () => SOLVER_ONCHAIN_RAIL,
   SWAP_LOCKUP_CONTRACT_KIND: () => SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL: () => SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE: () => SWAP_LOCKUP_CONTRACT_TYPE,
@@ -82,13 +86,16 @@ __export(index_exports, {
   buildHtlcClaim: () => buildHtlcClaim,
   buildHtlcRefund: () => buildHtlcRefund,
   cancelOffer: () => cancelOffer,
+  chainSourceFrom: () => chainSourceFrom,
   claimOnchainFill: () => claimOnchainFill,
   claimReceiveLockup: () => claimReceiveLockup,
   classifyDepositSpend: () => classifyDepositSpend,
   classifyOnchainHtlc: () => classifyOnchainHtlc,
   classifySpend: () => classifySpend,
+  covclaimdClient: () => covclaimdClient,
   createOffer: () => createOffer,
   createRfqSwapRecord: () => createRfqSwapRecord,
+  crossAssetRail: () => crossAssetRail,
   decodeOffer: () => decodeOffer,
   deriveLightningReceive: () => deriveLightningReceive,
   deriveOnchainReceive: () => deriveOnchainReceive,
@@ -103,6 +110,7 @@ __export(index_exports, {
   httpTransport: () => httpTransport,
   isRfqSwapTerminal: () => isRfqSwapTerminal,
   isRfqTerminal: () => isRfqTerminal,
+  l1ScriptForAddress: () => l1ScriptForAddress,
   lightningReceiveRequest: () => lightningReceiveRequest,
   lightningSendRequest: () => lightningSendRequest,
   lightningSendVtxoScript: () => lightningSendVtxoScript,
@@ -133,6 +141,8 @@ __export(index_exports, {
   requestOnchainSend: () => requestOnchainSend,
   restoreAssetSwaps: () => restoreAssetSwaps,
   retireSettledOfferContracts: () => retireSettledOfferContracts,
+  revealClaimPacket: () => revealClaimPacket,
+  revealFieldsFromScript: () => revealFieldsFromScript,
   rfqClaimSecretOf: () => rfqClaimSecretOf,
   rfqPair: () => rfqPair,
   rfqSecretsProfile: () => rfqSecretsProfile,
@@ -142,6 +152,11 @@ __export(index_exports, {
   sealClaimPacket: () => sealClaimPacket,
   senderIdentityForSwapRecord: () => senderIdentityForSwapRecord,
   shouldRetainRfqSwap: () => shouldRetainRfqSwap,
+  solverLightningRail: () => solverLightningRail,
+  solverLightningRendezvous: () => solverLightningRendezvous,
+  solverOnchainRail: () => solverOnchainRail,
+  solverOnchainRendezvous: () => solverOnchainRendezvous,
+  solverRendezvous: () => solverRendezvous,
   spendTxidsOf: () => spendTxidsOf,
   spendUpdate: () => spendUpdate,
   swapActivityResolver: () => swapActivityResolver,
@@ -1158,6 +1173,7 @@ var L1_NETWORKS = {
   testnet: btc.TEST_NETWORK,
   regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
 };
+var l1ScriptForAddress = (address, network) => btc.OutScript.encode(btc.Address(L1_NETWORKS[network]).decode(address));
 function onchainHtlcScript(params, network) {
   if (params.claimKey.length !== 32 || params.refundKey.length !== 32) {
     throw new Error("claimKey and refundKey must be 32-byte x-only keys");
@@ -1340,7 +1356,11 @@ async function classifyOnchainHtlc(chain, input) {
   const best = utxos.sort((a, b) => b.amount > a.amount ? 1 : -1)[0];
   if (!best) {
     if (!input.funding) return { phase: "unfunded" };
-    const spend = await chain.getSpendingTx(input.funding.txid, input.funding.vout);
+    const spend = await chain.getSpendingTx(
+      input.funding.txid,
+      input.funding.vout,
+      input.htlc.pkScript
+    );
     if (!spend) return { phase: "unfunded" };
     const preimage = extractPreimage(spend.txHex, input.htlc.paymentHash);
     const txid = btc.Transaction.fromRaw(import_base3.hex.decode(spend.txHex), {
@@ -1399,7 +1419,8 @@ function onchainSendProfile(result) {
     htlcLocktime: result.htlcParams.refundLocktime,
     network: result.l1Network,
     htlcAddress: result.htlc.address,
-    minConfirmations: result.minConfirmations
+    minConfirmations: result.minConfirmations,
+    payoutPkScript: import_base4.hex.encode(result.payoutPkScript)
   };
 }
 var OnchainSendCorridor = {
@@ -1448,6 +1469,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: import_base4.hex.decode(profile.payoutPkScript) } : {},
       ...profile.funding ? { funding: profile.funding } : {},
       ...profile.claimTxid ? { claimTxid: profile.claimTxid } : {}
     };
@@ -2045,6 +2069,43 @@ var assertFundable = (input) => {
   if (input.quote.refund_locktime !== void 0 && input.quote.refund_locktime - input.now < MIN_HEADROOM_SECONDS) {
     fail("insufficient_headroom", "refund deadline headroom below 90 minutes");
   }
+  if (input.maxFee) {
+    const { bps, sats, referenceRate } = input.maxFee;
+    if (bps === void 0 && sats === void 0) {
+      fail("max_fee_unbounded", "maxFee names neither bps nor sats");
+    }
+    if (bps !== void 0 && (!Number.isInteger(bps) || bps < 0 || bps > 1e4)) {
+      fail("max_fee_out_of_range", `maxFee.bps must be an integer in 0..10000, got ${bps}`);
+    }
+    if (sats !== void 0 && (!Number.isInteger(sats) || sats < 0)) {
+      fail("max_fee_out_of_range", `maxFee.sats must be a non-negative integer, got ${sats}`);
+    }
+    const legs = input.quote.pair.split("->");
+    const assetOf = (leg) => leg.slice(leg.indexOf(":") + 1);
+    const sameAsset = legs.length === 2 && assetOf(legs[0]) === assetOf(legs[1]);
+    if (!sameAsset && referenceRate === void 0) {
+      fail(
+        "fee_gate_unavailable",
+        `maxFee cannot gate ${input.quote.pair}: its legs name different assets, so from_amount - to_amount is not a fee. Supply maxFee.referenceRate (to-units per from-unit) from a source of your OWN \u2014 reading it off the solver's published feed would check the solver against its own number`
+      );
+    }
+    if (!sameAsset && (!Number.isFinite(referenceRate) || referenceRate <= 0)) {
+      fail(
+        "max_fee_out_of_range",
+        `maxFee.referenceRate must be a positive finite number, got ${referenceRate}`
+      );
+    }
+    const fee = sameAsset ? input.quote.from_amount - input.quote.to_amount : Math.ceil(
+      (input.quote.from_amount * referenceRate - input.quote.to_amount) / referenceRate
+    );
+    const allowed = Math.max(
+      sats ?? 0,
+      Math.floor(input.quote.from_amount * (bps ?? 0) / 1e4)
+    );
+    if (fee > allowed) {
+      fail("fee_too_high", `fee ${fee} exceeds the ${allowed} this client allows`);
+    }
+  }
   if (input.onchain) {
     const { htlcLocktime, minConfirmations, direction } = input.onchain;
     if (!Number.isInteger(minConfirmations) || minConfirmations < 1 || minConfirmations > MAX_MIN_CONFIRMATIONS) {
@@ -2348,7 +2409,7 @@ var lightningReceiveRequest = (input) => ({
     payment_hash: input.paymentHash,
     payout_address: input.payoutAddress,
     payout_pubkey: import_base10.hex.encode(input.payoutPubkey),
-    claim_packet: input.claimPacket
+    ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket }
   }
 });
 var onchainReceiveRequest = (input) => ({
@@ -2360,7 +2421,7 @@ var onchainReceiveRequest = (input) => ({
   amount: input.amount,
   profile: {
     payment_hash: input.paymentHash,
-    claim_packet: input.claimPacket,
+    ...input.claimPacket === void 0 ? {} : { claim_packet: input.claimPacket },
     refund_pubkey: import_base10.hex.encode(input.refundPubkey),
     payout_address: input.payoutAddress,
     payout_pubkey: import_base10.hex.encode(input.payoutPubkey)
@@ -2440,6 +2501,7 @@ async function requestOnchainSend(wallet, arkServerUrl, transport, params) {
       amountSide: params.amountSide
     })
   );
+  assertQuotedAmount(quote, params.amountSide, params.amount);
   const network = (0, import_sdk9.getNetwork)(info.network);
   const derived = deriveOnchainSend({
     quote,
@@ -2630,17 +2692,17 @@ async function requestLightningReceive(wallet, arkServerUrl, transport, params)
     new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
-  const claimPacket = await sealClaimPacket({
+  const claimPacket = params.covclaimdPubkey ? await sealClaimPacket({
     preimage,
     covclaimdPubkey: params.covclaimdPubkey
-  });
+  }) : void 0;
   const quote = await transport.requestQuote(
     lightningReceiveRequest({
       rfqId,
       paymentHash,
       payoutAddress,
       payoutPubkey,
-      claimPacket: claimPacket.ciphertext,
+      claimPacket: claimPacket?.ciphertext,
       amount: params.amount,
       amountSide: params.amountSide
     })
@@ -2753,10 +2815,10 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
     new import_sdk9.RestArkProvider(arkServerUrl).getInfo(),
     wallet.getAddress()
   ]);
-  const claimPacket = await sealClaimPacket({
+  const claimPacket = params.covclaimdPubkey ? await sealClaimPacket({
     preimage,
     covclaimdPubkey: params.covclaimdPubkey
-  });
+  }) : void 0;
   const quote = await transport.requestQuote(
     onchainReceiveRequest({
       rfqId,
@@ -2764,7 +2826,7 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
       payoutAddress,
       payoutPubkey,
       refundPubkey: params.refundPubkey,
-      claimPacket: claimPacket.ciphertext,
+      claimPacket: claimPacket?.ciphertext,
       amount: params.amount,
       amountSide: params.amountSide
     })
@@ -2815,16 +2877,550 @@ async function requestOnchainReceive(wallet, arkServerUrl, transport, params) {
   };
 }
 
-// src/claim.ts
+// src/chainSource.ts
+var btc2 = __toESM(require("@scure/btc-signer"), 1);
+var import_base11 = require("@scure/base");
+var addressOf = (pkScript, network) => btc2.Address(L1_NETWORKS[network]).encode(btc2.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: import_base11.hex.encode(raw) };
+    },
+    broadcast(txHex) {
+      return provider.broadcastTransaction(txHex);
+    },
+    async getMtp() {
+      return (await provider.getChainTip()).time;
+    }
+  };
+};
+
+// src/payment/rendezvous.ts
+var import_solver_discovery2 = require("@arkade-os/solver-discovery");
 var import_base12 = require("@scure/base");
-var import_legacy3 = require("@noble/hashes/legacy.js");
-var import_sha25 = require("@noble/hashes/sha2.js");
+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 = (0, import_solver_discovery2.sideLimits)(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 ? import_base12.hex.encode(fallbackEmulatorPubkey) : void 0;
+  if (encoded !== void 0 && !XONLY_HEX.test(encoded)) return void 0;
+  const pinned = encoded;
+  const candidates = (0, import_solver_discovery2.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
+var import_sdk11 = require("@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) => (0, import_sdk11.btcTarget)(req.raw) !== void 0,
+    available: async (req) => {
+      if ((0, import_sdk11.assetsOf)(req).length > 0) return false;
+      const address = (0, import_sdk11.btcTarget)(req.raw);
+      if (!address) return false;
+      try {
+        l1ScriptForAddress(address, deps.l1Network);
+      } catch {
+        return false;
+      }
+      const amount = (0, import_sdk11.tryResolveSendAmount)(req.raw, req.amount);
+      if (amount === void 0) return false;
+      return await rendezvousFor(amount) !== void 0;
+    },
+    quote: async (req, ctx) => {
+      const address = (0, import_sdk11.btcTarget)(req.raw);
+      (0, import_sdk11.assertNoAssets)(SOLVER_ONCHAIN_RAIL, req);
+      const amount = (0, import_sdk11.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 () => (0, import_sdk11.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
 var import_sdk12 = require("@arkade-os/sdk");
+var SOLVER_LIGHTNING_RAIL = "solver-lightning";
+var factsOf = (raw, decode, now) => {
+  const invoice = (0, import_sdk12.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) => (0, import_sdk12.invoiceTarget)(req.raw) !== void 0,
+    available: async (req) => {
+      if ((0, import_sdk12.assetsOf)(req).length > 0) return false;
+      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) => {
+      (0, import_sdk12.assertNoAssets)(SOLVER_LIGHTNING_RAIL, req);
+      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 () => (0, import_sdk12.makeHandle)(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/refund.ts
-var import_base11 = require("@scure/base");
+// src/payment/crossAsset.ts
+var import_sdk13 = require("@arkade-os/sdk");
+var CROSS_ASSET_RAIL = "cross-asset";
+var DEFAULT_CARRIER_SATS = 330;
+var parseAssetId = (assetId) => {
+  try {
+    return import_sdk13.asset.AssetId.fromString(assetId);
+  } catch {
+    return void 0;
+  }
+};
+function crossAssetRail(deps) {
+  const planFor = async (asset3) => {
+    const markets = await deps.discover();
+    const found = findMarket(markets, BTC_ASSET_ID, asset3.assetId);
+    const market = found?.market;
+    if (!market) return void 0;
+    const plan = await deps.quote(market, found.give, asset3.amount);
+    const [balance, dust] = await Promise.all([deps.btcBalance(), deps.dust()]);
+    return { plan, error: validatePlan(plan, balance, dust) };
+  };
+  return {
+    id: CROSS_ASSET_RAIL,
+    match: (req) => (0, import_sdk13.arkTarget)(req.raw) !== void 0,
+    available: async (req) => {
+      const assets = (0, import_sdk13.assetsOf)(req);
+      if (assets.length !== 1) return false;
+      const [asset3] = assets;
+      if (asset3.assetId === BTC_ASSET_ID) return false;
+      if (typeof asset3.amount !== "bigint" || asset3.amount <= 0n) return false;
+      if (!parseAssetId(asset3.assetId)) return false;
+      const planned = await planFor(asset3);
+      return planned !== void 0 && planned.error === void 0;
+    },
+    quote: async (req, ctx) => {
+      const payTo = (0, import_sdk13.arkTarget)(req.raw);
+      const asset3 = (0, import_sdk13.resolveAssetAmount)(CROSS_ASSET_RAIL, req);
+      const wantAsset = parseAssetId(asset3.assetId);
+      if (!wantAsset) {
+        throw new Error(
+          `${CROSS_ASSET_RAIL}: ${asset3.assetId} is not an asset id (expected 34 bytes of hex)`
+        );
+      }
+      const planned = await planFor(asset3);
+      if (!planned) {
+        throw new Error(`${CROSS_ASSET_RAIL}: no market swaps BTC into ${asset3.assetId}`);
+      }
+      if (planned.error) {
+        throw new Error(
+          `${CROSS_ASSET_RAIL}: cannot swap into ${asset3.assetId} \u2014 ${planned.error}`
+        );
+      }
+      const { plan } = planned;
+      if (!Number.isSafeInteger(Number(plan.deposit.atomic))) {
+        throw new Error(
+          `${CROSS_ASSET_RAIL}: deposit of ${plan.deposit.atomic} does not fit a JS number`
+        );
+      }
+      const depositSats = Number(plan.deposit.atomic);
+      const carrier = deps.carrierSats ?? DEFAULT_CARRIER_SATS;
+      return {
+        railId: CROSS_ASSET_RAIL,
+        // OPEN QUESTION for review: `total = amount + fee` forces the
+        // purchase price into `fee`, which reads as a service charge.
+        // A third field instead? `assets.spent` labels it correctly.
+        amount: carrier,
+        fee: depositSats,
+        total: depositSats + carrier,
+        assets: {
+          delivered: asset3,
+          spent: { assetId: BTC_ASSET_ID, amount: plan.deposit.atomic }
+        },
+        meta: {
+          market: plan.market.pair,
+          priceDisplay: plan.priceDisplay,
+          give: plan.give
+        },
+        send: async () => (0, import_sdk13.makeHandle)(CROSS_ASSET_RAIL, async (emit) => {
+          const offer = await createOffer(ctx.wallet, deps.arkServerUrl, {
+            wantAmount: asset3.amount,
+            wantAsset,
+            ...deps.emulatorPubkey ? { emulatorPubkey: deps.emulatorPubkey } : {}
+          });
+          const swap = {
+            phase: "quoted",
+            offerHex: offer.offerHex,
+            address: offer.address,
+            swapPkScript: offer.swapPkScript,
+            depositSats,
+            asset: asset3,
+            payTo,
+            plan
+          };
+          await deps.persist(swap);
+          await ctx.wallet.send({
+            address: offer.address,
+            amount: depositSats,
+            extensions: [offer.extension]
+          });
+          emit({ status: "sent" });
+          await deps.awaitFill(swap);
+          await deps.persist({ ...swap, phase: "filled" });
+          await deps.persist({ ...swap, phase: "paying" });
+          const txid = await ctx.wallet.send({
+            address: payTo,
+            amount: carrier,
+            assets: [asset3]
+          });
+          await deps.persist({ ...swap, phase: "settled", txid });
+          const result = {
+            railId: CROSS_ASSET_RAIL,
+            txid,
+            swapId: offer.offerHex
+          };
+          emit({ status: "settled", result });
+          return result;
+        })
+      };
+    }
+  };
+}
+
+// src/reveal.ts
+var import_base13 = require("@scure/base");
+var import_legacy3 = require("@noble/hashes/legacy.js");
 var import_sha24 = require("@noble/hashes/sha2.js");
-var import_sdk11 = require("@arkade-os/sdk");
+var import_sdk14 = require("@arkade-os/sdk");
+var CovclaimdRevealError = class extends Error {
+  name = "CovclaimdRevealError";
+  status;
+  detail;
+  retryable;
+  constructor(what, status, detail) {
+    super(`covclaimd ${what} failed: ${status || "no response"} ${detail}`.trimEnd());
+    this.status = status;
+    this.detail = detail;
+    this.retryable = status === 0 || status === 429 || status >= 500;
+  }
+};
+var decodeKey = (value, field) => {
+  if (typeof value !== "string") throw new Error(`covclaimd info: ${field} is not a string`);
+  let bytes;
+  try {
+    bytes = import_base13.hex.decode(value);
+  } catch {
+    throw new Error(`covclaimd info: ${field} is not hex`);
+  }
+  if (bytes.length !== 33) {
+    throw new Error(`covclaimd info: ${field} must be 33-byte compressed, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var LOOPBACK = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+var assertTransportSecure = (baseUrl, allowInsecureHttp) => {
+  const { protocol, hostname } = new URL(baseUrl);
+  if (protocol === "https:" || allowInsecureHttp) return;
+  if (protocol === "http:" && LOOPBACK.has(hostname)) return;
+  throw new Error(
+    `covclaimd URL must be https (got ${protocol}//${hostname}): the key it serves is the one the preimage gets sealed to. Pass allowInsecureHttp to override.`
+  );
+};
+var covclaimdClient = (baseUrl, options = {}) => {
+  assertTransportSecure(baseUrl, options.allowInsecureHttp === true);
+  const url = baseUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const send = async (what, path, init) => {
+    let response;
+    try {
+      response = await fetchImpl(`${url}${path}`, {
+        ...init,
+        // a redirect would move the key fetch off the vetted origin
+        redirect: "error",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (error) {
+      throw new CovclaimdRevealError(what, 0, String(error));
+    }
+    if (!response.ok) {
+      throw new CovclaimdRevealError(what, response.status, await response.text());
+    }
+    return response;
+  };
+  const readJson = async (what, response) => {
+    const body = await response.text();
+    try {
+      return JSON.parse(body);
+    } catch {
+      throw new CovclaimdRevealError(
+        what,
+        response.status,
+        `non-JSON body: ${body.slice(0, 200)}`
+      );
+    }
+  };
+  return {
+    async info() {
+      const response = await send("info", "/v1/preimage/covclaimd-pubkey", {
+        method: "GET"
+      });
+      const body = await readJson("info", response);
+      return {
+        covclaimdPubkey: decodeKey(body?.covclaimd_pub_key, "covclaimd_pub_key"),
+        emulatorPubkey: import_base13.hex.encode(decodeKey(body?.emulator_pub_key, "emulator_pub_key"))
+      };
+    },
+    async reveal(params) {
+      await send("reveal", "/v1/reveal", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          swap_address: params.swapAddress,
+          packet: { ciphertext: params.ciphertext, arkade_script: params.arkadeScript },
+          taptree: params.taptree
+        })
+      });
+    }
+  };
+};
+function revealFieldsFromScript(script) {
+  if (!script.nonInteractiveClaimArkadeScript) {
+    throw new Error("this covenant has no non-interactive claim leaf to reveal against");
+  }
+  return {
+    arkadeScript: import_base13.base64.encode(script.nonInteractiveClaimArkadeScript),
+    taptree: import_base13.hex.encode(script.encode())
+  };
+}
+async function revealClaimPacket(client, input) {
+  const fields = revealFieldsFromScript(input.script);
+  if (import_base13.hex.encode(import_sdk14.ArkAddress.decode(input.address).pkScript) !== import_base13.hex.encode(input.script.pkScript)) {
+    throw new Error("address does not belong to this covenant");
+  }
+  if (import_base13.hex.encode((0, import_legacy3.ripemd160)((0, import_sha24.sha256)(input.preimage))) !== import_base13.hex.encode(input.script.options.preimageHash)) {
+    throw new Error("preimage does not match the covenant's payment hash");
+  }
+  const { ciphertext } = await sealClaimPacket({
+    preimage: input.preimage,
+    covclaimdPubkey: (await client.info()).covclaimdPubkey
+  });
+  await client.reveal({ swapAddress: input.address, ciphertext, ...fields });
+  return { ciphertext };
+}
+
+// src/claim.ts
+var import_base15 = require("@scure/base");
+var import_legacy4 = require("@noble/hashes/legacy.js");
+var import_sha26 = require("@noble/hashes/sha2.js");
+var import_sdk16 = require("@arkade-os/sdk");
+
+// src/refund.ts
+var import_base14 = require("@scure/base");
+var import_sha25 = require("@noble/hashes/sha2.js");
+var import_sdk15 = require("@arkade-os/sdk");
 var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var isRfqTerminal = (state) => RFQ_TERMINAL_STATES.includes(state);
 var RFQ_RESOLVED_STATES = ["settled", "refunded"];
@@ -2871,7 +3467,7 @@ var LockupNeedsRecoveryError = class extends Error {
   }
 };
 async function findLockupVtxos(indexer, swapPkScript) {
-  const scripts = [import_base11.hex.encode(swapPkScript)];
+  const scripts = [import_base14.hex.encode(swapPkScript)];
   const [spendable, recoverable] = await Promise.all([
     indexer.getVtxos({ scripts, spendableOnly: true }),
     indexer.getVtxos({ scripts, recoverableOnly: true })
@@ -2897,16 +3493,16 @@ async function findLockupVtxos(indexer, swapPkScript) {
   }
   return out;
 }
-var hashesTo = (candidate, paymentHash) => import_base11.hex.encode((0, import_sha24.sha256)(candidate)) === paymentHash;
+var hashesTo = (candidate, paymentHash) => import_base14.hex.encode((0, import_sha25.sha256)(candidate)) === paymentHash;
 var candidateWitnessItems = (tx, inputIndex) => [
-  ...(0, import_sdk11.getArkPsbtFields)(tx, inputIndex, import_sdk11.ConditionWitness).flat(),
+  ...(0, import_sdk15.getArkPsbtFields)(tx, inputIndex, import_sdk15.ConditionWitness).flat(),
   ...tx.getInput(inputIndex).finalScriptWitness ?? []
 ];
 async function readLockupFate(indexer, input) {
-  const { vtxos } = await indexer.getVtxos({ scripts: [import_base11.hex.encode(input.swapPkScript)] });
+  const { vtxos } = await indexer.getVtxos({ scripts: [import_base14.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));
+  const exited = all.filter((vtxo) => vtxo.isUnrolled && !(0, import_sdk15.hasTerminalSpend)(vtxo));
   if (exited.length > 0) {
     return {
       fate: "exited",
@@ -2916,7 +3512,7 @@ async function readLockupFate(indexer, input) {
   const spentBy = /* @__PURE__ */ new Map();
   let everySpendNamed = true;
   for (const vtxo of all) {
-    if (!(0, import_sdk11.hasTerminalSpend)(vtxo)) return { fate: "open" };
+    if (!(0, import_sdk15.hasTerminalSpend)(vtxo)) return { fate: "open" };
     if (vtxo.spentBy)
       spentBy.set(vtxo.spentBy, {
         checkpointTxid: vtxo.spentBy,
@@ -2930,7 +3526,7 @@ async function readLockupFate(indexer, input) {
   for (const raw of txs) {
     let tx;
     try {
-      tx = import_sdk11.Transaction.fromPSBT(import_base11.base64.decode(raw));
+      tx = import_sdk15.Transaction.fromPSBT(import_base14.base64.decode(raw));
     } catch {
       continue;
     }
@@ -2938,7 +3534,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 = import_base11.hex.encode(spent.txid);
+      const txid = import_base14.hex.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)) {
@@ -2967,14 +3563,14 @@ async function pushRefundWithoutReceiver(ark, input) {
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk11.CSVMultisigTapscript.decode(import_base11.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk15.CSVMultisigTapscript.decode(import_base14.hex.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
   const leaf = input.script.refundWithoutReceiver();
   const tapTree = input.script.encode();
   const amount = input.vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
-  const { arkTx, checkpoints } = (0, import_sdk11.buildOffchainTx)(
+  const { arkTx, checkpoints } = (0, import_sdk15.buildOffchainTx)(
     input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
       vout: vtxo.vout,
@@ -2987,18 +3583,18 @@ async function pushRefundWithoutReceiver(ark, input) {
   );
   const signedArkTx = await input.sender.sign(arkTx);
   const submitted = await ark.submitTx(
-    import_base11.base64.encode(signedArkTx.toPSBT()),
-    checkpoints.map((c) => import_base11.base64.encode(c.toPSBT()))
+    import_base14.base64.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => import_base14.base64.encode(c.toPSBT()))
   );
-  (0, import_sdk11.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
-  const matched = (0, import_sdk11.matchServerCheckpoints)(
+  (0, import_sdk15.assertSubmittedArkTxid)(submitted, signedArkTx, "refundWithoutReceiver");
+  const matched = (0, import_sdk15.matchServerCheckpoints)(
     submitted.signedCheckpointTxs,
     checkpoints,
     "refundWithoutReceiver"
   );
   const finalCheckpoints = await Promise.all(
     matched.map(
-      async ({ server }) => import_base11.base64.encode((await input.sender.sign(server, [0])).toPSBT())
+      async ({ server }) => import_base14.base64.encode((await input.sender.sign(server, [0])).toPSBT())
     )
   );
   await ark.finalizeTx(submitted.arkTxid, finalCheckpoints);
@@ -3093,20 +3689,20 @@ async function pushClaim(ark, input) {
     }
   }
   const committed = input.script.options.preimageHash;
-  if (import_base12.hex.encode((0, import_legacy3.ripemd160)((0, import_sha25.sha256)(input.preimage))) !== import_base12.hex.encode(committed)) {
+  if (import_base15.hex.encode((0, import_legacy4.ripemd160)((0, import_sha26.sha256)(input.preimage))) !== import_base15.hex.encode(committed)) {
     throw new Error("preimage does not match the covenant's payment hash");
   }
   const info = await ark.getInfo();
   let serverUnrollScript;
   try {
-    serverUnrollScript = import_sdk12.CSVMultisigTapscript.decode(import_base12.hex.decode(info.checkpointTapscript));
+    serverUnrollScript = import_sdk16.CSVMultisigTapscript.decode(import_base15.hex.decode(info.checkpointTapscript));
   } catch {
     throw new Error("invalid checkpointTapscript from the Arkade server");
   }
   const leaf = input.script.claim();
   const tapTree = input.script.encode();
-  const arkTxid = await (0, import_sdk12.signAndSubmitOffchainTx)({
-    identity: (0, import_sdk12.claimWithPreimageIdentity)(input.receiver, input.preimage),
+  const arkTxid = await (0, import_sdk16.signAndSubmitOffchainTx)({
+    identity: (0, import_sdk16.claimWithPreimageIdentity)(input.receiver, input.preimage),
     provider: ark,
     inputs: input.vtxos.map((vtxo) => ({
       txid: vtxo.txid,
@@ -3153,7 +3749,7 @@ async function claimReceiveLockup(indexer, ark, input) {
 }
 
 // src/refundBlocked.ts
-var import_sdk13 = require("@arkade-os/sdk");
+var import_sdk17 = require("@arkade-os/sdk");
 var RefundNotLocallyPossibleError = class extends Error {
   constructor(reason, message, options) {
     super(message, options);
@@ -3170,16 +3766,16 @@ async function senderIdentityForSwapRecord(wallet, record) {
     );
   }
   try {
-    return await (0, import_sdk13.contractSigner)(wallet, record.signingDescriptor);
+    return await (0, import_sdk17.contractSigner)(wallet, record.signingDescriptor);
   } catch (cause) {
-    if (cause instanceof import_sdk13.WalletCannotSignError) {
+    if (cause instanceof import_sdk17.WalletCannotSignError) {
       throw new RefundNotLocallyPossibleError(
         "unsignable-wallet",
         `this wallet holds ${record.signingDescriptor} but cannot sign with it; attach its signer`,
         { cause }
       );
     }
-    if (cause instanceof import_sdk13.ForeignDescriptorError) {
+    if (cause instanceof import_sdk17.ForeignDescriptorError) {
       throw new RefundNotLocallyPossibleError(
         "foreign-descriptor",
         `this wallet cannot derive ${record.signingDescriptor}; the swap was created on another wallet`,
@@ -3214,7 +3810,7 @@ function arkadeRefunder(deps) {
 }
 
 // src/swapManager.ts
-var import_base13 = require("@scure/base");
+var import_base16 = require("@scure/base");
 function nextOnchainAction(input) {
   switch (input.phase.phase) {
     case "unfunded":
@@ -3662,7 +4258,7 @@ var RfqSwapManager = class {
   // ── internals ────────────────────────────────────────────────────────────
   track(swap) {
     this.monitored.set(swap.rfqId, swap);
-    this.byLockupScript.set(import_base13.hex.encode(swap.lockupPkScript), swap);
+    this.byLockupScript.set(import_base16.hex.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
@@ -3671,7 +4267,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(import_base13.hex.encode(swap.lockupPkScript));
+    if (swap) this.byLockupScript.delete(import_base16.hex.encode(swap.lockupPkScript));
     this.monitored.delete(rfqId);
     this.refundRefused.delete(rfqId);
     this.lastClaimError.delete(rfqId);
@@ -3733,7 +4329,7 @@ var RfqSwapManager = class {
     if (!lockup) {
       try {
         const [existing] = await contracts.getContracts({
-          script: import_base13.hex.encode(swap.lockupPkScript)
+          script: import_base16.hex.encode(swap.lockupPkScript)
         });
         if (existing) {
           this.registered.set(swap.rfqId, true);
@@ -3752,13 +4348,13 @@ var RfqSwapManager = class {
       );
       return;
     }
-    const script = import_base13.hex.encode(lockup.script.pkScript);
-    if (script !== import_base13.hex.encode(swap.lockupPkScript)) {
+    const script = import_base16.hex.encode(lockup.script.pkScript);
+    if (script !== import_base16.hex.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 ${import_base13.hex.encode(swap.lockupPkScript)}`
+          `swap ${swap.rfqId} lockup script ${script} does not match its lockupPkScript ${import_base16.hex.encode(swap.lockupPkScript)}`
         )
       );
       return;
@@ -3777,7 +4373,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(import_base13.hex.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
+    void this.deps.contracts.setContractWatchState(import_base16.hex.encode(swap.lockupPkScript), "retained").catch((error) => this.emitFailed(swap, error));
   }
   arm() {
     if (!this.running) return;
@@ -4250,8 +4846,8 @@ var errorMessage = (error) => error instanceof Error ? error.message : String(er
 var outpointKey = (vtxo) => `${vtxo.txid}:${vtxo.vout}`;
 
 // src/activity.ts
-var import_sdk14 = require("@arkade-os/sdk");
-var import_base14 = require("@scure/base");
+var import_sdk18 = require("@arkade-os/sdk");
+var import_base17 = require("@scure/base");
 var LABELS = {
   lightning_send: "Lightning send",
   lightning_receive: "Lightning receive",
@@ -4326,7 +4922,7 @@ async function activityInputOf(record, indexer) {
 async function lockupTxids(indexer, record, wantFunding) {
   let script;
   try {
-    script = import_base14.hex.encode(import_sdk14.ArkAddress.decode(record.lockupAddress).pkScript);
+    script = import_base17.hex.encode(import_sdk18.ArkAddress.decode(record.lockupAddress).pkScript);
   } catch {
     return [];
   }
@@ -4348,6 +4944,8 @@ async function lockupTxids(indexer, record, wantFunding) {
   ARKADE_BTC,
   AddressMismatch,
   BTC_ASSET_ID,
+  CROSS_ASSET_RAIL,
+  CovclaimdRevealError,
   InMemoryAssetSwapRepository,
   IndexedDbAssetSwapRepository,
   LIGHTNING_BTC,
@@ -4380,6 +4978,8 @@ async function lockupTxids(indexer, record, wantFunding) {
   RfqSwapManager,
   RfqSwapOriginRequired,
   SOLO_REFUND_HEADROOM_SECONDS,
+  SOLVER_LIGHTNING_RAIL,
+  SOLVER_ONCHAIN_RAIL,
   SWAP_LOCKUP_CONTRACT_KIND,
   SWAP_LOCKUP_CONTRACT_LABEL,
   SWAP_LOCKUP_CONTRACT_TYPE,
@@ -4396,13 +4996,16 @@ async function lockupTxids(indexer, record, wantFunding) {
   buildHtlcClaim,
   buildHtlcRefund,
   cancelOffer,
+  chainSourceFrom,
   claimOnchainFill,
   claimReceiveLockup,
   classifyDepositSpend,
   classifyOnchainHtlc,
   classifySpend,
+  covclaimdClient,
   createOffer,
   createRfqSwapRecord,
+  crossAssetRail,
   decodeOffer,
   deriveLightningReceive,
   deriveOnchainReceive,
@@ -4417,6 +5020,7 @@ async function lockupTxids(indexer, record, wantFunding) {
   httpTransport,
   isRfqSwapTerminal,
   isRfqTerminal,
+  l1ScriptForAddress,
   lightningReceiveRequest,
   lightningSendRequest,
   lightningSendVtxoScript,
@@ -4447,6 +5051,8 @@ async function lockupTxids(indexer, record, wantFunding) {
   requestOnchainSend,
   restoreAssetSwaps,
   retireSettledOfferContracts,
+  revealClaimPacket,
+  revealFieldsFromScript,
   rfqClaimSecretOf,
   rfqPair,
   rfqSecretsProfile,
@@ -4456,6 +5062,11 @@ async function lockupTxids(indexer, record, wantFunding) {
   sealClaimPacket,
   senderIdentityForSwapRecord,
   shouldRetainRfqSwap,
+  solverLightningRail,
+  solverLightningRendezvous,
+  solverOnchainRail,
+  solverOnchainRendezvous,
+  solverRendezvous,
   spendTxidsOf,
   spendUpdate,
   swapActivityResolver,