Merge pull request #1071 from synonymdev/fix/hw-sign-fee-display

fix: show mining fee in hw sign fee grid

Author: jvsena42

app/src/main/java/to/bitkit/ui/screens/transfer/hardware/SpendingHwSignScreen.kt

@@ -36,6 +36,7 @@ import to.bitkit.ui.screens.transfer.previewBtOrder
 import to.bitkit.ui.theme.AppThemeSurface
 import to.bitkit.ui.theme.Colors
 import to.bitkit.ui.utils.withAccent
+import to.bitkit.models.safe
 import to.bitkit.viewmodels.TransferViewModel
 
 @Composable
@@ -54,8 +55,9 @@ fun SpendingHwSignScreen(
         return
     }
 
-    LaunchedEffect(deviceId) {
+    LaunchedEffect(deviceId, order.id) {
         viewModel.warmUpHardwareConnection(deviceId)
+        viewModel.updateHwFundingFeeEstimate(order, deviceId)
     }
 
     DisposableEffect(viewModel) {
@@ -64,6 +66,7 @@ fun SpendingHwSignScreen(
 
     Content(
         order = order,
+        miningFeeSats = state.hwMiningFeeSats,
         isAdvanced = state.isAdvanced,
         isSigning = state.isSigning,
         hasPendingBroadcast = state.hasPendingHwBroadcast,
@@ -78,6 +81,7 @@ fun SpendingHwSignScreen(
 @Composable
 private fun Content(
     order: IBtOrder,
+    miningFeeSats: ULong = 0uL,
     isAdvanced: Boolean = false,
     isSigning: Boolean = false,
     hasPendingBroadcast: Boolean = false,
@@ -119,7 +123,10 @@ private fun Content(
                 )
                 VerticalSpacer(16.dp)
 
-                SpendingHwFeeGrid(order = order)
+                SpendingHwFeeGrid(
+                    order = order,
+                    miningFeeSats = miningFeeSats,
+                )
 
                 VerticalSpacer(24.dp)
 
@@ -171,19 +178,23 @@ private fun Content(
 internal fun SpendingHwFeeGrid(
     order: IBtOrder,
     modifier: Modifier = Modifier,
+    miningFeeSats: ULong = 0uL,
 ) {
+    val lspFee = order.feeSat.safe() - order.clientBalanceSat.safe()
+    val total = order.feeSat.safe() + miningFeeSats.safe()
+
     Column(modifier = modifier) {
         Row(
             horizontalArrangement = Arrangement.spacedBy(16.dp),
             modifier = Modifier.height(IntrinsicSize.Min)
         ) {
             FeeInfo(
                 label = stringResource(R.string.lightning__spending_confirm__network_fee),
-                amount = order.networkFeeSat.toLong(),
+                amount = miningFeeSats.toLong(),
             )
             FeeInfo(
                 label = stringResource(R.string.lightning__spending_confirm__lsp_fee),
-                amount = order.serviceFeeSat.toLong(),
+                amount = lspFee.toLong(),
             )
         }
         Row(
@@ -196,12 +207,28 @@ internal fun SpendingHwFeeGrid(
             )
             FeeInfo(
                 label = stringResource(R.string.lightning__spending_confirm__total),
-                amount = order.feeSat.toLong(),
+                amount = total.toLong(),
             )
         }
     }
 }
 
+@Preview(showSystemUi = true)
+@Composable
+private fun PreviewWithMiningFee() {
+    AppThemeSurface {
+        Content(
+            order = previewBtOrder(
+                networkFeeSat = 528uL,
+                serviceFeeSat = 132uL,
+                clientBalanceSat = 7_042uL,
+                feeSat = 7_402uL,
+            ),
+            miningFeeSats = 141uL,
+        )
+    }
+}
+
 @Preview(showSystemUi = true)
 @Composable
 private fun Preview() {

app/src/main/java/to/bitkit/ui/screens/transfer/hardware/SpendingHwSignedScreen.kt

@@ -51,12 +51,17 @@ fun SpendingHwSignedScreen(
         onContinue()
     }
 
-    Content(order = order, onBackClick = onCloseClick)
+    Content(
+        order = order,
+        miningFeeSats = state.hwMiningFeeSats,
+        onBackClick = onCloseClick,
+    )
 }
 
 @Composable
 private fun Content(
     order: IBtOrder,
+    miningFeeSats: ULong = 0uL,
     onBackClick: () -> Unit = {},
 ) {
     ScreenColumn {
@@ -85,7 +90,10 @@ private fun Content(
                 )
                 VerticalSpacer(16.dp)
 
-                SpendingHwFeeGrid(order = order)
+                SpendingHwFeeGrid(
+                    order = order,
+                    miningFeeSats = miningFeeSats,
+                )
             }
         }
     }

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

@@ -100,6 +100,7 @@ class TransferViewModel @Inject constructor(
     fun setTransferEffect(effect: TransferEffect) = viewModelScope.launch { transferEffects.emit(effect) }
     var maxLspFee = 0uL
     private var hwTransferSignJob: Job? = null
+    private var hwFeeEstimateJob: Job? = null
     private var pendingHwFundingBroadcast: PendingHwFundingBroadcast? = null
     private var activeHwTransferDeviceId: String? = null
 
@@ -193,11 +194,14 @@ class TransferViewModel @Inject constructor(
                     spendingBalanceSats = oldOrder.clientBalanceSat,
                     receivingBalanceSats = receivingAmountSats.toULong(),
                 ).getOrThrow()
+                hwFeeEstimateJob?.cancel()
+                hwFeeEstimateJob = null
                 _spendingUiState.update {
                     it.copy(
                         order = newOrder,
                         defaultOrder = oldOrder,
                         isAdvanced = true,
+                        hwMiningFeeSats = 0uL,
                     )
                 }
                 setTransferEffect(TransferEffect.OnOrderCreated)
@@ -393,12 +397,15 @@ class TransferViewModel @Inject constructor(
     private suspend fun onOrderCreated(order: IBtOrder) {
         settingsStore.update { it.copy(lightningSetupStep = 0) }
         pendingHwFundingBroadcast = null
+        hwFeeEstimateJob?.cancel()
+        hwFeeEstimateJob = null
         _spendingUiState.update {
             it.copy(
                 order = order,
                 isAdvanced = false,
                 defaultOrder = null,
                 hasPendingHwBroadcast = false,
+                hwMiningFeeSats = 0uL,
             )
         }
         setTransferEffect(TransferEffect.OnOrderCreated)
@@ -497,18 +504,23 @@ class TransferViewModel @Inject constructor(
 
     fun onUseDefaultLspBalanceClick() {
         val defaultOrder = _spendingUiState.value.defaultOrder
+        hwFeeEstimateJob?.cancel()
+        hwFeeEstimateJob = null
         _spendingUiState.update {
             it.copy(
                 order = defaultOrder,
                 defaultOrder = null,
                 isAdvanced = false,
+                hwMiningFeeSats = 0uL,
             )
         }
     }
 
     fun resetSpendingState() {
         hwTransferSignJob?.cancel()
         hwTransferSignJob = null
+        hwFeeEstimateJob?.cancel()
+        hwFeeEstimateJob = null
         pendingHwFundingBroadcast = null
         activeHwTransferDeviceId = null
         _spendingUiState.update { TransferToSpendingUiState() }
@@ -520,6 +532,8 @@ class TransferViewModel @Inject constructor(
         val deviceId = activeHwTransferDeviceId
         hwTransferSignJob?.cancel()
         hwTransferSignJob = null
+        hwFeeEstimateJob?.cancel()
+        hwFeeEstimateJob = null
         _spendingUiState.update { it.copy(isSigning = false) }
         if (deviceId != null) {
             viewModelScope.launch {
@@ -564,6 +578,41 @@ class TransferViewModel @Inject constructor(
         hwWalletRepo.warmUpKnownDevice(deviceId)
     }
 
+    /** Best-effort offline mining-fee estimate for the Sign screen (xpub compose, no device session). */
+    fun updateHwFundingFeeEstimate(order: IBtOrder, deviceId: String) {
+        hwFeeEstimateJob?.cancel()
+        hwFeeEstimateJob = viewModelScope.launch {
+            if (_spendingUiState.value.hasPendingHwBroadcast) return@launch
+            val address = order.payment?.onchain?.address.orEmpty()
+            if (address.isEmpty()) return@launch
+            val orderId = order.id
+
+            runSuspendCatching {
+                val satsPerVByte = hwFundingSatsPerVByte()
+                hwWalletRepo.composeFundingTransaction(
+                    deviceId = deviceId,
+                    address = address,
+                    sats = order.feeSat,
+                    satsPerVByte = satsPerVByte,
+                ).getOrThrow().miningFeeSats
+            }.onSuccess { miningFeeSats ->
+                _spendingUiState.update { state ->
+                    val activeOrderId = state.order?.id
+                    if ((activeOrderId != null && activeOrderId != orderId) || state.hasPendingHwBroadcast) {
+                        state
+                    } else {
+                        state.copy(hwMiningFeeSats = miningFeeSats)
+                    }
+                }
+            }.onFailure {
+                Logger.debug(
+                    "Skipped offline hardware funding fee estimate for '$deviceId'",
+                    context = TAG,
+                )
+            }
+        }
+    }
+
     fun onTransferToSpendingHwConfirm(order: IBtOrder, deviceId: String) {
         if (hwTransferSignJob?.isActive == true) return
 
@@ -614,6 +663,9 @@ class TransferViewModel @Inject constructor(
             val signedTx = pendingHwFundingBroadcast
                 ?.takeIf { it.matches(order, deviceId, address) }
                 ?.signedTx
+                ?.also { pending ->
+                    _spendingUiState.update { state -> state.copy(hwMiningFeeSats = pending.miningFeeSats) }
+                }
                 ?: prepareSignedHardwareFunding(order, deviceId, address).also {
                     pendingHwFundingBroadcast = PendingHwFundingBroadcast(
                         orderId = order.id,
@@ -622,7 +674,12 @@ class TransferViewModel @Inject constructor(
                         amountSats = order.feeSat,
                         signedTx = it,
                     )
-                    _spendingUiState.update { state -> state.copy(hasPendingHwBroadcast = true) }
+                    _spendingUiState.update { state ->
+                        state.copy(
+                            hasPendingHwBroadcast = true,
+                            hwMiningFeeSats = it.miningFeeSats,
+                        )
+                    }
                 }
             broadcastHardwareFunding(signedTx)
         }
@@ -645,6 +702,7 @@ class TransferViewModel @Inject constructor(
             sats = order.feeSat,
             satsPerVByte = satsPerVByte,
         )
+        _spendingUiState.update { it.copy(hwMiningFeeSats = funding.miningFeeSats) }
         return signHardwareFunding(deviceId, funding)
     }
 
@@ -1100,6 +1158,7 @@ data class TransferToSpendingUiState(
     val isLoading: Boolean = false,
     val isSigning: Boolean = false,
     val hasPendingHwBroadcast: Boolean = false,
+    val hwMiningFeeSats: ULong = 0uL,
     val receivingAmount: Long = 0,
     val feeEstimate: Long? = null,
 )

app/src/test/java/to/bitkit/viewmodels/TransferViewModelTest.kt

@@ -220,6 +220,86 @@ class TransferViewModelTest : BaseUnitTest() {
         verify(blocktankRepo).estimateOrderFee(eq(ON_CHAIN_BALANCE.safe() - fallbackReserve.safe()), any(), any())
     }
 
+    @Test
+    fun `updateHwFundingFeeEstimate sets mining fee before signing`() = test {
+        val order = previewBtOrder()
+        val funding = HwFundingTransaction(
+            psbt = "psbt",
+            miningFeeSats = MINING_FEE,
+            feeRate = FEE_RATE.toFloat(),
+            totalSpent = order.feeSat + MINING_FEE,
+            satsPerVByte = FEE_RATE,
+        )
+        whenever(lightningRepo.getFeeRateForSpeed(any(), anyOrNull())).thenReturn(Result.success(FEE_RATE))
+        whenever(hwWalletRepo.composeFundingTransaction(any(), any(), any(), any())).thenReturn(Result.success(funding))
+
+        sut.updateHwFundingFeeEstimate(order, DEVICE_ID)
+        advanceUntilIdle()
+
+        assertEquals(MINING_FEE, sut.spendingUiState.value.hwMiningFeeSats)
+        verify(hwWalletRepo).composeFundingTransaction(
+            eq(DEVICE_ID),
+            eq(order.payment?.onchain?.address.orEmpty()),
+            eq(order.feeSat),
+            eq(FEE_RATE),
+        )
+        verify(hwWalletRepo, never()).signFunding(any(), any())
+    }
+
+    @Test
+    fun `updateHwFundingFeeEstimate ignores superseded estimate`() = test {
+        val orderA = previewBtOrder()
+        val orderB = previewBtOrder().copy(id = "order-b-id")
+        val staleCompose = CompletableDeferred<Result<HwFundingTransaction>>()
+        val fundingB = HwFundingTransaction(
+            psbt = "psbt-b",
+            miningFeeSats = 999uL,
+            feeRate = FEE_RATE.toFloat(),
+            totalSpent = orderB.feeSat + 999uL,
+            satsPerVByte = FEE_RATE,
+        )
+        val staleFunding = HwFundingTransaction(
+            psbt = "psbt-a",
+            miningFeeSats = MINING_FEE,
+            feeRate = FEE_RATE.toFloat(),
+            totalSpent = orderA.feeSat + MINING_FEE,
+            satsPerVByte = FEE_RATE,
+        )
+
+        whenever(blocktankRepo.calculateLiquidityOptions(any()))
+            .thenReturn(Result.success(liquidityOptionsForCreate(maxClientBalanceSat = OPTION_MAX_CLIENT_BALANCE)))
+        whenever(blocktankRepo.createOrder(any(), any(), any()))
+            .thenReturn(Result.success(orderA))
+            .thenReturn(Result.success(orderB))
+        whenever(lightningRepo.getFeeRateForSpeed(any(), anyOrNull())).thenReturn(Result.success(FEE_RATE))
+        whenever(hwWalletRepo.composeFundingTransaction(any(), any(), any(), any())).doSuspendableAnswer {
+            if (sut.spendingUiState.value.order?.id == orderA.id) {
+                staleCompose.await()
+            } else {
+                Result.success(fundingB)
+            }
+        }
+
+        sut.onConfirmAmount(OPTION_MAX_CLIENT_BALANCE.toLong())
+        advanceUntilIdle()
+
+        sut.updateHwFundingFeeEstimate(orderA, DEVICE_ID)
+        runCurrent()
+
+        sut.onSpendingAdvancedContinue(LSP_BALANCE.toLong())
+        advanceUntilIdle()
+
+        sut.updateHwFundingFeeEstimate(orderB, DEVICE_ID)
+        advanceUntilIdle()
+
+        assertEquals(999uL, sut.spendingUiState.value.hwMiningFeeSats)
+
+        staleCompose.complete(Result.success(staleFunding))
+        advanceUntilIdle()
+
+        assertEquals(999uL, sut.spendingUiState.value.hwMiningFeeSats)
+    }
+
     @Test
     fun `onTransferToSpendingHwConfirm signs the funding send and records the paid order`() = test {
         val order = previewBtOrder()
@@ -249,6 +329,7 @@ class TransferViewModelTest : BaseUnitTest() {
         sut.onTransferToSpendingHwConfirm(order, DEVICE_ID)
         advanceUntilIdle()
 
+        assertEquals(MINING_FEE, sut.spendingUiState.value.hwMiningFeeSats)
         verify(hwWalletRepo).composeFundingTransaction(
             eq(DEVICE_ID),
             eq(order.payment?.onchain?.address.orEmpty()),
@@ -910,6 +991,13 @@ class TransferViewModelTest : BaseUnitTest() {
         maxClientBalanceSat = maxClientBalanceSat,
     )
 
+    private fun liquidityOptionsForCreate(maxClientBalanceSat: ULong) = ChannelLiquidityOptions(
+        defaultLspBalanceSat = LSP_BALANCE,
+        minLspBalanceSat = LSP_BALANCE,
+        maxLspBalanceSat = LSP_BALANCE,
+        maxClientBalanceSat = maxClientBalanceSat,
+    )
+
     private fun btInfo(lspMaxClientBalance: ULong): IBtInfo {
         val options = mock<IBtInfoOptions>()
         whenever(options.maxClientBalanceSat).thenReturn(lspMaxClientBalance)

changelog.d/next/1071.fixed.md

@@ -0,0 +1 @@
+Hardware wallet transfer sign screens now show the on-chain mining fee and total outflow that matches Trezor confirmation.