Merge pull request #378 from synonymdev/fix/reserve-fee-amount

Reserve a fee amount when trying to sent all on-chain balance

Author: jvsena42

app/src/main/java/to/bitkit/models/BalanceState.kt

@@ -7,5 +7,6 @@ data class BalanceState(
     val totalOnchainSats: ULong = 0uL,
     val totalLightningSats: ULong = 0uL,
     val maxSendLightningSats: ULong = 0uL, // TODO use where applicable
+    val maxSendOnchainSats: ULong = 0uL,
     val totalSats: ULong = 0uL,
 )

app/src/main/java/to/bitkit/repositories/LightningRepo.kt

@@ -520,6 +520,7 @@ class LightningRepo @Inject constructor(
         feeRates: FeeRates? = null,
         isTransfer: Boolean = false,
         channelId: String? = null,
+        isMaxAmount: Boolean = false,
     ): Result<Txid> =
         executeWhenNodeRunning("Send on-chain") {
             val transactionSpeed = speed ?: settingsStore.data.first().defaultTransactionSpeed
@@ -538,6 +539,7 @@ class LightningRepo @Inject constructor(
                 sats = sats,
                 satsPerVByte = satsPerVByte,
                 utxosToSpend = finalUtxosToSpend,
+                isMaxAmount = isMaxAmount
             )
             cacheStore.addTransactionMetadata(
                 TransactionMetadata(
@@ -699,6 +701,10 @@ class LightningRepo @Inject constructor(
     fun getBalances(): BalanceDetails? =
         if (_lightningState.value.nodeLifecycleState.isRunning()) lightningService.balances else null
 
+    suspend fun getBalancesAsync(): Result<BalanceDetails> = executeWhenNodeRunning("getBalancesAsync") {
+        Result.success(checkNotNull(lightningService.balances))
+    }
+
     fun getStatus(): NodeStatus? =
         if (_lightningState.value.nodeLifecycleState.isRunning()) lightningService.status else null
 

app/src/main/java/to/bitkit/repositories/WalletRepo.kt

@@ -31,6 +31,7 @@ import to.bitkit.ext.totalNextOutboundHtlcLimitSats
 import to.bitkit.models.AddressModel
 import to.bitkit.models.BalanceState
 import to.bitkit.models.NodeLifecycleState
+import to.bitkit.models.TransactionSpeed
 import to.bitkit.models.toDerivationPath
 import to.bitkit.services.CoreService
 import to.bitkit.utils.AddressChecker
@@ -160,18 +161,22 @@ class WalletRepo @Inject constructor(
     }
 
     suspend fun syncBalances() {
-        lightningRepo.getBalances()?.let { balance ->
+        lightningRepo.getBalancesAsync().onSuccess { balance ->
+            _walletState.update { it.copy(balanceDetails = balance) }
+
             val totalSats = balance.totalLightningBalanceSats + balance.totalOnchainBalanceSats
 
             val newBalance = BalanceState(
                 totalOnchainSats = balance.totalOnchainBalanceSats,
                 totalLightningSats = balance.totalLightningBalanceSats,
                 maxSendLightningSats = lightningRepo.getChannels()?.totalNextOutboundHtlcLimitSats() ?: 0u,
+                maxSendOnchainSats = getMaxSendAmount(),
                 totalSats = totalSats,
             )
             _balanceState.update { newBalance }
-            _walletState.update { it.copy(balanceDetails = lightningRepo.getBalances()) }
             saveBalanceState(newBalance)
+        }.onFailure {
+            Logger.warn("Could not sync balances", context = TAG)
         }
     }
 
@@ -318,24 +323,6 @@ class WalletRepo @Inject constructor(
         _balanceState.update { balanceState }
     }
 
-    suspend fun getMaxSendAmount(): ULong = withContext(bgDispatcher) {
-        val totalOnchainSats = balanceState.value.totalOnchainSats
-        if (totalOnchainSats == 0uL) {
-            return@withContext 0uL
-        }
-
-        try {
-            val fee = lightningRepo.calculateTotalFee(totalOnchainSats).getOrThrow()
-            val maxSendable = (totalOnchainSats - fee).coerceAtLeast(0u)
-
-            return@withContext maxSendable
-        } catch (_: Throwable) {
-            Logger.debug("Could not calculate max send amount, using as fallback 90% of total", context = TAG)
-            val fallbackMax = (totalOnchainSats.toDouble() * 0.9).toULong()
-            return@withContext fallbackMax
-        }
-    }
-
     // BIP21 state management
     fun updateBip21AmountSats(amount: ULong?) {
         _walletState.update { it.copy(bip21AmountSats = amount) }
@@ -478,6 +465,25 @@ class WalletRepo @Inject constructor(
         }
     }
 
+    private suspend fun getMaxSendAmount(): ULong = withContext(bgDispatcher) {
+        val spendableOnchainSats = walletState.value.balanceDetails?.spendableOnchainBalanceSats ?: 0uL
+        if (spendableOnchainSats == 0uL) {
+            return@withContext 0uL
+        }
+        val fallbackMaxFee = (spendableOnchainSats.toDouble() * FALLBACK_FEE_PERCENT).toULong()
+
+        val fee = lightningRepo.calculateTotalFee(
+            amountSats = spendableOnchainSats,
+            speed = TransactionSpeed.default(),
+            utxosToSpend = lightningRepo.listSpendableOutputs().getOrNull()
+        ).onFailure {
+            Logger.debug("Could not calculate max send fee, using as fallback 10% of total", context = TAG)
+        }.getOrDefault(fallbackMaxFee)
+
+        val maxSendable = (spendableOnchainSats - fee).coerceAtLeast(0u)
+        maxSendable
+    }
+
     private suspend fun Scanner.OnChain.extractLightningHash(): String? {
         val lightningInvoice: String = this.invoice.params?.get("lightning") ?: return null
         val decoded = decode(lightningInvoice)
@@ -494,6 +500,7 @@ class WalletRepo @Inject constructor(
 
     private companion object {
         const val TAG = "WalletRepo"
+        const val FALLBACK_FEE_PERCENT = 0.1
     }
 }
 

app/src/main/java/to/bitkit/services/CoreService.kt

@@ -414,7 +414,7 @@ class ActivityService(
         }
 
         if (onChain.id in cacheStore.data.first().deletedActivities && !forceUpdate) {
-            Logger.debug("Activity ${onChain.id} was already deleted, skipping", context = TAG)
+            Logger.verbose("Activity ${onChain.id} was already deleted, skipping", context = TAG)
             return
         }
 

app/src/main/java/to/bitkit/services/LightningService.kt

@@ -447,18 +447,27 @@ class LightningService @Inject constructor(
         sats: ULong,
         satsPerVByte: UInt,
         utxosToSpend: List<SpendableUtxo>? = null,
+        isMaxAmount: Boolean = false
     ): Txid {
         val node = this.node ?: throw ServiceError.NodeNotSetup
 
-        Logger.info("Sending $sats sats to $address with satsPerVByte=$satsPerVByte")
+        Logger.info("Sending $sats sats to $address, satsPerVByte=$satsPerVByte, isMaxAmount = $isMaxAmount")
 
         return ServiceQueue.LDK.background {
-            node.onchainPayment().sendToAddress(
-                address = address,
-                amountSats = sats,
-                feeRate = convertVByteToKwu(satsPerVByte),
-                utxosToSpend = utxosToSpend,
-            )
+            if (isMaxAmount) {
+                node.onchainPayment().sendAllToAddress(
+                    address = address,
+                    retainReserve = true,
+                    feeRate = FeeRate.fromSatPerVbUnchecked(satsPerVByte.toULong()),
+                )
+            } else {
+                node.onchainPayment().sendToAddress(
+                    address = address,
+                    amountSats = sats,
+                    feeRate = convertVByteToKwu(satsPerVByte),
+                    utxosToSpend = utxosToSpend,
+                )
+            }
         }
     }
 

app/src/main/java/to/bitkit/ui/screens/transfer/external/ExternalNodeViewModel.kt

@@ -53,7 +53,7 @@ class ExternalNodeViewModel @Inject constructor(
     private fun observeState() {
         viewModelScope.launch {
             walletRepo.balanceState.collect {
-                val maxAmount = walletRepo.getMaxSendAmount()
+                val maxAmount = walletRepo.balanceState.value.maxSendOnchainSats
                 _uiState.update { it.copy(amount = it.amount.copy(max = maxAmount.toLong())) }
             }
         }

app/src/main/java/to/bitkit/ui/screens/wallets/send/SendAmountScreen.kt

@@ -102,7 +102,7 @@ fun SendAmountScreen(
         }.takeIf { canGoBack },
         onClickMax = { maxSats ->
             // TODO port the RN sendMax logic if still needed
-            if (uiState.payMethod == SendMethod.LIGHTNING && uiState.lnurl == null) {
+            if (uiState.lnurl == null) {
                 app?.toast(
                     type = Toast.ToastType.WARNING,
                     title = context.getString(R.string.wallet__send_max_spending__title),
@@ -190,7 +190,7 @@ private fun SendAmountNodeRunning(
 
         val availableAmount = when {
             isLnurlWithdraw -> uiState.lnurl.data.maxWithdrawableSat().toLong()
-            uiState.payMethod == SendMethod.ONCHAIN -> balances.totalOnchainSats.toLong()
+            uiState.payMethod == SendMethod.ONCHAIN -> balances.maxSendOnchainSats.toLong()
             else -> balances.maxSendLightningSats.toLong()
         }
 

app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt

@@ -1103,6 +1103,8 @@ class AppViewModel @Inject constructor(
             sats = amount,
             speed = _sendUiState.value.speed,
             utxosToSpend = _sendUiState.value.selectedUtxos,
+            isMaxAmount = _sendUiState.value.payMethod == SendMethod.ONCHAIN &&
+                amount == walletRepo.balanceState.value.maxSendOnchainSats
         )
     }
 

app/src/main/java/to/bitkit/viewmodels/TransferViewModel.kt

@@ -218,7 +218,7 @@ class TransferViewModel @Inject constructor(
             _spendingUiState.update { it.copy(isLoading = true) }
 
             // Get the max available balance discounting onChain fee
-            val availableAmount = walletRepo.getMaxSendAmount()
+            val availableAmount = walletRepo.balanceState.value.maxSendOnchainSats
 
             withTimeoutOrNull(1.minutes) {
                 isNodeRunning.first { it }

app/src/test/java/to/bitkit/repositories/LightningRepoTest.kt

@@ -388,7 +388,8 @@ class LightningRepoTest : BaseUnitTest() {
                 address = any(),
                 sats = any(),
                 satsPerVByte = any(),
-                utxosToSpend = anyOrNull()
+                utxosToSpend = anyOrNull(),
+                isMaxAmount = any()
             )
         ).thenReturn("testPaymentId")