fix(background): probe even with same currency

.eslintrc.json

@@ -36,6 +36,7 @@
         "html": true
       }
     ],
+    "no-constant-condition": "off",
     "no-console": "warn",
     "react/prop-types": "off",
     "block-scoped-var": "error",

src/background/services/monetization.ts

@@ -106,6 +106,7 @@ export class MonetizationService {
 
     if (enabled && this.canTryPayment(connected, state)) {
       sessionsArr.forEach((session) => {
+        if (!sessions.get(session.id)) return
         const source = replacedSessions.has(session.id)
           ? 'request-id-reused'
           : 'new-link'

src/background/services/paymentSession.ts

@@ -20,7 +20,6 @@ import type { MonetizationEventDetails } from '@/shared/messages'
 import type { AmountValue } from '@/shared/types'
 import type { Logger } from '@/shared/logger'
 
-const DEFAULT_INTERVAL_MS = 1000
 const HOUR_MS = 3600 * 1000
 const MIN_SEND_AMOUNT = 1n // 1 unit
 
@@ -59,83 +58,78 @@ export class PaymentSession {
 
     // The amount that needs to be sent every second.
     // In senders asset scale already.
-    const amountToSend = BigInt(this.rate) / 3600n
+    let amountToSend = BigInt(this.rate) / 3600n
     const senderAssetScale = this.sender.assetScale
     const receiverAssetScale = this.receiver.assetScale
-
-    // This all will eventually get replaced by OpenPayments response update
-    // that includes a min rate that we can directly use.
-    if (this.sender.assetCode !== this.receiver.assetCode) {
-      await this.setIncomingPaymentUrl()
-      for (const amount of getNextSendableAmount(
-        senderAssetScale,
-        receiverAssetScale,
-        bigIntMax(amountToSend, MIN_SEND_AMOUNT)
-      )) {
-        if (this.probingId !== localProbingId) {
-          // In future we can throw `new AbortError()`
-          throw new DOMException('Aborting existing probing', 'AbortError')
-        }
-        try {
-          await this.openPaymentsService.probeDebitAmount(
-            amount,
-            this.incomingPaymentUrl,
-            this.sender
-          )
-          this.setAmount(BigInt(amount))
-          return
-        } catch (e) {
-          if (isTokenExpiredError(e)) {
-            await this.openPaymentsService.rotateToken()
-          } else if (isNonPositiveAmountError(e)) {
-            continue
-          } else {
-            throw e
-          }
+    const isCrossCurrency = this.sender.assetCode !== this.receiver.assetCode
+
+    if (!isCrossCurrency) {
+      if (amountToSend <= MIN_SEND_AMOUNT) {
+        // We need to add another unit when using a debit amount, since
+        // @interledger/pay subtracts one unit.
+        if (senderAssetScale <= receiverAssetScale) {
+          amountToSend = MIN_SEND_AMOUNT + 1n
+        } else if (senderAssetScale > receiverAssetScale) {
+          // If the sender scale is greater than the receiver scale, the unit
+          // issue will not be present.
+          amountToSend = MIN_SEND_AMOUNT
         }
       }
-      return
-    }
-
-    if (amountToSend <= MIN_SEND_AMOUNT) {
-      // We need to add another unit when using a debit amount, since
-      // @interledger/pay subtracts one unit.
-      if (senderAssetScale <= receiverAssetScale) {
-        this.setAmount(MIN_SEND_AMOUNT + 1n)
-        return
-      }
 
-      // If the sender scale is greater than the receiver scale, the unit issue
-      // will not be present.
+      // If the sender can facilitate the rate, but the amount can not be
+      // represented in the receiver's scale we need to send the minimum amount
+      // for the receiver (1 unit, but in the sender's asset scale)
       if (senderAssetScale > receiverAssetScale) {
-        this.setAmount(MIN_SEND_AMOUNT)
-        return
+        const amountInReceiversScale = convert(
+          amountToSend,
+          senderAssetScale,
+          receiverAssetScale
+        )
+
+        if (amountInReceiversScale === 0n) {
+          amountToSend = convert(
+            MIN_SEND_AMOUNT,
+            receiverAssetScale,
+            senderAssetScale
+          )
+        }
       }
     }
 
-    // If the sender can facilitate the rate, but the amount can not be
-    // represented in the receiver's scale we need to send the minimum amount
-    // for the receiver (1 unit, but in the sender's asset scale)
-    if (senderAssetScale > receiverAssetScale) {
-      const amountInReceiversScale = convert(
-        amountToSend,
-        senderAssetScale,
-        receiverAssetScale
-      )
+    // This all will eventually get replaced by OpenPayments response update
+    // that includes a min rate that we can directly use.
+    await this.setIncomingPaymentUrl()
+    const amountIter = getNextSendableAmount(
+      senderAssetScale,
+      receiverAssetScale,
+      bigIntMax(amountToSend, MIN_SEND_AMOUNT)
+    )
 
-      if (amountInReceiversScale === 0n) {
-        const amount = convert(
-          MIN_SEND_AMOUNT,
-          receiverAssetScale,
-          senderAssetScale
+    amountToSend = BigInt(amountIter.next().value)
+    while (true) {
+      if (this.probingId !== localProbingId) {
+        // In future we can throw `new AbortError()`
+        throw new DOMException('Aborting existing probing', 'AbortError')
+      }
+      try {
+        await this.openPaymentsService.probeDebitAmount(
+          amountToSend.toString(),
+          this.incomingPaymentUrl,
+          this.sender
         )
-        this.setAmount(amount)
-        return
+        this.setAmount(amountToSend)
+        break
+      } catch (e) {
+        if (isTokenExpiredError(e)) {
+          await this.openPaymentsService.rotateToken()
+        } else if (isNonPositiveAmountError(e)) {
+          amountToSend = BigInt(amountIter.next().value)
+          continue
+        } else {
+          throw e
+        }
       }
     }
-
-    this.amount = amountToSend.toString()
-    this.intervalInMs = DEFAULT_INTERVAL_MS
   }
 
   get id() {

src/background/utils.ts

@@ -111,7 +111,7 @@ export function* getNextSendableAmount(
   senderAssetScale: number,
   receiverAssetScale: number,
   amount: bigint = 0n
-): IterableIterator<AmountValue> {
+): Generator<AmountValue, never, never> {
   const EXPONENTIAL_INCREASE = 0.5
 
   const scaleDiff =