use real probe when doing wrap fee estimation

huumn · huumn · commit a940c73d417e · 2025-12-11T19:15:14.000-06:00
diff --git a/api/lnd/index.js b/api/lnd/index.js
@@ -3,6 +3,7 @@ import { toPositiveNumber } from '@/lib/format'
 import { authenticatedLndGrpc } from '@/lib/lnd'
 import { randomBytes } from 'crypto'
 import { chanNumber } from 'bolt07'
+import { once } from 'events'
 import { getIdentity, getHeight, getWalletInfo, getNode, getPayment, parsePaymentRequest } from 'ln-service'
 
 const lnd = global.lnd || authenticatedLndGrpc({
@@ -22,10 +23,8 @@ getWalletInfo({ lnd }, (err, result) => {
   console.log('LND GRPC connection successful')
 })
 
-// we don't use this because it doesn't solve https://github.com/lightningnetwork/lnd/discussions/10427
-// due to this bug, real probes cause the channel to be marked as unusable and the real payment fails
-// this should be useful in the future though when need more control over probing
-export async function rawProbePayment ({ lnd, request, maxFeeMsat, timeoutSeconds, maxCltvDelta }) {
+// we create our own probe because estimateRouteFee is busted https://github.com/lightningnetwork/lnd/discussions/10427
+export async function estimateRouteFeeProbe ({ lnd, request, maxFeeMsat, timeoutSeconds, maxCltvDelta }) {
   if (!request) {
     throw new Error('Payment request is required')
   }
@@ -34,11 +33,11 @@ export async function rawProbePayment ({ lnd, request, maxFeeMsat, timeoutSecond
     allow_self_payment: true,
     amt_msat: inv.mtokens,
     cancelable: true,
-    cltv_limit: maxCltvDelta,
+    cltv_limit: maxCltvDelta ? toPositiveNumber(maxCltvDelta) : undefined,
     dest: Buffer.from(inv.destination, 'hex'),
     dest_custom_records: undefined,
     dest_features: inv.features.map(n => n.bit),
-    fee_limit_msat: maxFeeMsat,
+    fee_limit_msat: maxFeeMsat ? toPositiveNumber(maxFeeMsat) : undefined,
     final_cltv_delta: inv.cltv_delta,
     last_hop_pubkey: undefined,
     max_parts: 1,
@@ -47,7 +46,7 @@ export async function rawProbePayment ({ lnd, request, maxFeeMsat, timeoutSecond
     outgoing_chan_id: undefined,
     outgoing_chan_ids: [],
     payment_addr: Buffer.from(inv.payment, 'hex'),
-    payment_hash: randomBytes(32),
+    payment_hash: randomBytes(32), // this is what makes it a probe
     payment_request: undefined,
     route_hints: inv.routes?.map(r => ({
       hop_hints: r.slice(1).map((h, i) => ({
@@ -59,20 +58,23 @@ export async function rawProbePayment ({ lnd, request, maxFeeMsat, timeoutSecond
       }))
     })) ?? [],
     time_pref: 1,
-    timeout_seconds: timeoutSeconds
+    timeout_seconds: timeoutSeconds ? toPositiveNumber(timeoutSeconds) : undefined
   }
-  return await new Promise((resolve, reject) => {
-    const sub = lnd.router.sendPaymentV2(params)
-    sub.on('data', (res) => {
-      resolve(res)
-    })
-    sub.on('error', (err) => {
-      reject(err)
-    })
-    sub.on('end', () => {
-      reject(new Error('Payment timed out'))
-    })
-  })
+  const sub = lnd.router.sendPaymentV2(params)
+  const [probe] = await once(sub, 'data')
+
+  // a successful probe returns FAILURE_REASON_INCORRECT_PAYMENT_DETAILS
+  if (probe.failure_reason === 'FAILURE_REASON_INCORRECT_PAYMENT_DETAILS') {
+    // there's only one htlc in the probe, because max_parts is 1
+    const { htlcs: [{ route: { total_fees_msat: routingFeeMsat, total_time_lock: timeLockDelay } }] } = probe
+    return {
+      routingFeeMsat: toPositiveNumber(routingFeeMsat),
+      // because we are simulating estimateRouteFee's probe, we remove the final hop's cltv_delta
+      timeLockDelay: toPositiveNumber(timeLockDelay - inv.cltv_delta)
+    }
+  }
+
+  throw new Error(`Unable to estimate route: ${probe.failure_reason || 'unknown reason'}`)
 }
 
 export async function estimateRouteFee ({ lnd, destination, tokens, mtokens, request, timeout }) {
@@ -97,6 +99,7 @@ export async function estimateRouteFee ({ lnd, destination, tokens, mtokens, req
     // XXX we don't use the payment request anymore because it causes the channel to be marked as unusable
     // and the real payment fails see: https://github.com/lightningnetwork/lnd/discussions/10427
     // without the request, the estimate is a statistical estimate based on past payments
+    // NOTE: this should be fixed in v0.20.1-beta
     request = false
   }
 
diff --git a/wallets/server/wrap.js b/wallets/server/wrap.js
@@ -1,5 +1,5 @@
 import { createHodlInvoice, parsePaymentRequest } from 'ln-service'
-import lnd, { estimateRouteFee, getBlockHeight } from '@/api/lnd'
+import lnd, { estimateRouteFeeProbe, getBlockHeight } from '@/api/lnd'
 import { toPositiveBigInt, toPositiveNumber } from '@/lib/format'
 import { PayInFailureReasonError } from '@/api/payIn/errors'
 
@@ -145,12 +145,12 @@ async function wrapBolt11Params ({ msats, bolt11, maxRoutingFeeMsats, hideInvoic
 
     // get routing estimates
     const { routingFeeMsat, timeLockDelay } =
-      await estimateRouteFee({
+      await estimateRouteFeeProbe({
         lnd,
-        destination: inv.destination,
-        mtokens: inv.mtokens,
         request: bolt11,
-        timeout: FEE_ESTIMATE_TIMEOUT_SECS
+        maxFeeMsat: maxRoutingFeeMsats,
+        timeoutSeconds: FEE_ESTIMATE_TIMEOUT_SECS,
+        maxCltvDelta: MAX_OUTGOING_CLTV_DELTA
       })
 
     const blockHeight = await getBlockHeight({ lnd })
