Reduce Rush fee when balance is above minimum but below minimum + fee (#128)

Reduce Rush fee when balance is above minimum but below minimum + fee

When a user's balance exceeds the minimum withdrawal amount but is
insufficient to cover the Rush fee, reduce the Rush fee at speed selection
time so the withdrawal amount is exactly the minimum (5,000 sats).
Priority speed remains unselectable in these circumstances.

Author: Synesso

outie/src/main/kotlin/xyz/block/bittycity/outie/controllers/InfoCollectionController.kt

@@ -463,6 +463,7 @@ class SpeedHandler @Inject constructor(
             selectable = isSelectable(
               speedOption,
               amount,
+              currentBalance,
               Bitcoins(amountFreeTierMin),
               Bitcoins(minimum),
               Bitcoins(amountFreeTierMin),
@@ -472,51 +473,55 @@ class SpeedHandler @Inject constructor(
         } else {
           speedOption.copy(selectable = false)
         }
-      else ->
-        if (currentBalance.units < amountFreeTierMin) {
-          val minAmount = Bitcoins(minimum)
-          val maxAmount = currentBalance - speedOption.totalFee
-          speedOption.copy(
-            minimumAmount = minAmount,
-            maximumAmount = maxAmount,
-            selectable = isSelectable(
-              speedOption,
-              amount,
-              Bitcoins(amountFreeTierMin),
-              Bitcoins(minimum),
-              minAmount,
-              maxAmount
-            )
-          )
+      else -> {
+        val minAmount = Bitcoins(minimum)
+        val maxAmount = currentBalance - speedOption.totalFee
+        // For Rush, if the fee pushes maxAmount below minAmount but the balance exceeds
+        // the minimum, the fee will be reduced at selection time. Reflect that here so the
+        // global min/max check in getHurdles doesn't reject the withdrawal.
+        val effectiveMaxAmount = if (
+          speedOption.speed == RUSH &&
+          maxAmount < minAmount &&
+          currentBalance > minAmount
+        ) {
+          minAmount
         } else {
-          val minAmount = Bitcoins(minimum)
-          val maxAmount = currentBalance - speedOption.totalFee
-          speedOption.copy(
-            minimumAmount = minAmount,
-            maximumAmount = maxAmount,
-            selectable = isSelectable(
-              speedOption,
-              amount,
-              Bitcoins(amountFreeTierMin),
-              Bitcoins(minimum),
-              minAmount,
-              maxAmount
-            )
-          )
+          maxAmount
         }
+        speedOption.copy(
+          minimumAmount = minAmount,
+          maximumAmount = effectiveMaxAmount,
+          selectable = isSelectable(
+            speedOption,
+            amount,
+            currentBalance,
+            Bitcoins(amountFreeTierMin),
+            Bitcoins(minimum),
+            minAmount,
+            effectiveMaxAmount
+          )
+        )
+      }
     }
   }
 
   @Suppress("LongParameterList")
   fun isSelectable(
     speedOption: WithdrawalSpeedOption,
     amount: Bitcoins,
+    currentBalance: Bitcoins,
     amountFreeTierMin: Bitcoins,
     minimumAmount: Bitcoins,
     calculatedMinAmount: Bitcoins,
     calculatedMaxAmount: Bitcoins,
   ): Boolean? = when (speedOption.speed) {
     STANDARD -> amount >= amountFreeTierMin
+    RUSH -> {
+      // Rush is selectable if the customer's balance exceeds the minimum withdrawal amount,
+      // even if fees would normally push maxAmount below minAmount. In that case, the fee
+      // will be reduced at selection time so the withdrawal amount is exactly the minimum.
+      amount >= minimumAmount && currentBalance > minimumAmount
+    }
     else -> {
       amount >= minimumAmount && calculatedMaxAmount >= calculatedMinAmount
     }
@@ -537,17 +542,32 @@ class SpeedHandler @Inject constructor(
     val selectedSpeed = response.selectedSpeed
       ?: raise(ParameterIsRequired(value.customerId, "selectedSpeed"))
 
+    val storedOption =
+      withdrawalStore.findSpeedOptionByWithdrawalTokenAndSpeed(value.id, selectedSpeed).bind()
+        ?: raise(
+          IllegalStateException(
+            "No speed option for speed $selectedSpeed for withdrawal ${value.id}"
+          )
+        )
+
+    // For Rush speed, if the normal fee would push the withdrawal amount below the minimum,
+    // reduce the fee so the customer can withdraw exactly the minimum amount.
+    val effectiveOption = if (
+      storedOption.speed == RUSH &&
+      balance - storedOption.totalFee < Bitcoins(minimum) &&
+      balance > Bitcoins(minimum)
+    ) {
+      val reducedFee = balance - Bitcoins(minimum)
+      storedOption.copy(
+        totalFee = reducedFee,
+        totalFeeFiatEquivalent = bitcoinsToUsd(reducedFee, exchangeRate),
+      )
+    } else {
+      storedOption
+    }
+
     val option =
-      addAmountsAndSelectability(
-        withdrawalStore.findSpeedOptionByWithdrawalTokenAndSpeed(value.id, selectedSpeed).bind()
-          ?: raise(
-            IllegalStateException(
-              "No speed option for speed $selectedSpeed for withdrawal ${value.id}"
-            )
-          ),
-        balance,
-        amount
-      ).map {
+      addAmountsAndSelectability(effectiveOption, balance, amount).map {
         addAdjustedAmount(it, amount, exchangeRate).bind()
       }.bind()
 

outie/src/test/kotlin/xyz/block/bittycity/outie/controllers/SpeedHandlerTest.kt

@@ -189,7 +189,7 @@ class SpeedHandlerTest : BittyCityTestCase() {
   }
 
   @Test
-  fun `it's impossible to withdraw a balance that is too low`() = runTest {
+  fun `rush is selectable with reduced fee when balance barely covers minimum`() = runTest {
     val amount = Bitcoins(6_999L)
     val withdrawal = data.seedWithdrawal(
       state = CollectingInfo,
@@ -200,6 +200,39 @@ class SpeedHandlerTest : BittyCityTestCase() {
 
     setupFakes(currentBalance)
 
+    val speedHurdle = (
+      subject.getHurdles(withdrawal, currentBalance).getOrThrow()
+        .first() as WithdrawalHurdle.SpeedHurdle
+      )
+
+    speedHurdle.withdrawalSpeedOptions.size shouldBe 3
+    speedHurdle.withdrawalSpeedOptions[0].should { priority ->
+      priority.selectable shouldBe false
+      priority.adjustedAmount.shouldBeNull()
+    }
+    speedHurdle.withdrawalSpeedOptions[1].should { rush ->
+      rush.selectable shouldBe true
+      rush.maximumAmount shouldBe Bitcoins(5_000L)
+      rush.adjustedAmount shouldBe Bitcoins(5_000L)
+    }
+    speedHurdle.withdrawalSpeedOptions[2].should { standard ->
+      standard.selectable shouldBe false
+      standard.adjustedAmount.shouldBeNull()
+    }
+  }
+
+  @Test
+  fun `it's impossible to withdraw a balance that is too low`() = runTest {
+    val amount = Bitcoins(5_000L)
+    val withdrawal = data.seedWithdrawal(
+      state = CollectingInfo,
+      walletAddress = data.targetWalletAddress,
+      amount = amount
+    )
+    val currentBalance = Bitcoins(5_000L)
+
+    setupFakes(currentBalance)
+
     shouldThrow<InsufficientBalance> {
       (
         subject.getHurdles(withdrawal, currentBalance).getOrThrow()