Merge pull request #689 from synonymdev/claude/issue-680-20260120-1548

fix: improve gift code flow

Author: jvsena42

AGENTS.md

@@ -178,6 +178,7 @@ suspend fun getData(): Result<Data> = withContext(Dispatchers.IO) {
 - NEVER use `runBlocking` in suspend functions
 - ALWAYS pass the TAG as context to `Logger` calls, e.g. `Logger.debug("message", context = TAG)`
 - NEVER add `e = ` named parameter to Logger calls
+- NEVER manually append the `Throwable`'s message or any other props to the string passed as the 1st param of `Logger.*` calls, its internals are already enriching the final log message with the details of the `Throwable` passed via the `e` arg
 - ALWAYS log errors at the final handling layer where the error is acted upon, not in intermediate layers that just propagate it
 - ALWAYS use the Result API instead of try-catch
 - NEVER wrap methods returning `Result<T>` in try-catch
@@ -221,4 +222,4 @@ suspend fun getData(): Result<Data> = withContext(Dispatchers.IO) {
 - Use `LightningRepo` to defining the business logic for the node operations, usually delegating to `LightningService`
 - Use `WakeNodeWorker` to manage the handling of remote notifications received via cloud messages
 - Use `*Services` to wrap rust library code exposed via bindings
-- Use CQRS pattern of Command + Handler like it's done in the `NotifyPaymentReceived` + `NotifyPaymentReceivedHandler` setup 
+- Use CQRS pattern of Command + Handler like it's done in the `NotifyPaymentReceived` + `NotifyPaymentReceivedHandler` setup

app/build.gradle.kts

@@ -54,8 +54,8 @@ android {
         applicationId = "to.bitkit"
         minSdk = 28
         targetSdk = 36
-        versionCode = 171
-        versionName = "2.0.0-rc.5"
+        versionCode = 172
+        versionName = "2.0.0-rc.6"
         testInstrumentationRunner = "to.bitkit.test.HiltTestRunner"
         vectorDrawables {
             useSupportLibrary = true

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

@@ -427,6 +427,8 @@ class BlocktankRepo @Inject constructor(
             require(code.isNotBlank()) { "Gift code cannot be blank" }
             require(amount > 0u) { "Gift amount must be positive" }
 
+            Logger.debug("Starting gift code claim: amount=$amount, timeout=$waitTimeout", context = TAG)
+
             lightningRepo.executeWhenNodeRunning(
                 operationName = "claimGiftCode",
                 waitTimeout = waitTimeout,
@@ -436,9 +438,16 @@ class BlocktankRepo @Inject constructor(
                 val channels = lightningRepo.getChannelsAsync().getOrThrow()
                 val maxInboundCapacity = channels.calculateRemoteBalance()
 
+                Logger.debug(
+                    "Liquidity check: maxInbound=$maxInboundCapacity, required=$amount",
+                    context = TAG
+                )
+
                 if (maxInboundCapacity >= amount) {
-                    Result.success(claimGiftCodeWithLiquidity(code))
+                    Logger.debug("Sufficient liquidity available, claiming with existing channel", context = TAG)
+                    Result.success(claimGiftCodeWithLiquidity(code, amount))
                 } else {
+                    Logger.debug("Insufficient liquidity, opening new channel", context = TAG)
                     Result.success(claimGiftCodeWithoutLiquidity(code, amount))
                 }
             }.getOrThrow()
@@ -447,33 +456,53 @@ class BlocktankRepo @Inject constructor(
         }
     }
 
-    private suspend fun claimGiftCodeWithLiquidity(code: String): GiftClaimResult {
+    private suspend fun claimGiftCodeWithLiquidity(code: String, amount: ULong): GiftClaimResult {
         val invoice = lightningRepo.createInvoice(
             amountSats = null,
             description = "blocktank-gift-code:$code",
             expirySeconds = 3600u,
         ).getOrThrow()
 
-        ServiceQueue.CORE.background {
+        Logger.debug("Created invoice for gift code, requesting payment from LSP", context = TAG)
+
+        val giftResponse = ServiceQueue.CORE.background {
             giftPay(invoice = invoice)
         }
 
-        return GiftClaimResult.SuccessWithLiquidity
+        Logger.debug("Gift payment request completed: id=${giftResponse.id}", context = TAG)
+
+        return GiftClaimResult.SuccessWithLiquidity(
+            paymentHashOrTxId = giftResponse.bolt11PaymentId ?: giftResponse.id,
+            sats = giftResponse.bolt11Payment?.paidSat?.toLong()
+                ?: giftResponse.appliedGiftCode?.giftSat?.toLong()
+                ?: amount.toLong(),
+            invoice = invoice,
+            code = code,
+        )
     }
 
     private suspend fun claimGiftCodeWithoutLiquidity(code: String, amount: ULong): GiftClaimResult {
         val nodeId = lightningService.nodeId ?: throw ServiceError.NodeNotStarted()
 
+        Logger.debug("Creating gift order for code (insufficient liquidity)", context = TAG)
+
         val order = ServiceQueue.CORE.background {
             giftOrder(clientNodeId = nodeId, code = "blocktank-gift-code:$code")
         }
 
-        val orderId = checkNotNull(order.orderId) { "Order ID is null" }
+        val orderId = checkNotNull(order.orderId) { "Order ID is null after gift order creation" }
+        Logger.debug("Gift order created: $orderId", context = TAG)
 
         val openedOrder = openChannel(orderId).getOrThrow()
+        Logger.debug("Channel opened for gift order: ${openedOrder.id}", context = TAG)
+
+        val fundingTxId = openedOrder.channel?.fundingTx?.id
+        if (fundingTxId == null) {
+            Logger.warn("Channel opened but funding transaction ID is null", context = TAG)
+        }
 
         return GiftClaimResult.SuccessWithoutLiquidity(
-            paymentHashOrTxId = openedOrder.channel?.fundingTx?.id ?: orderId,
+            paymentHashOrTxId = fundingTxId ?: orderId,
             sats = amount.toLong(),
             invoice = openedOrder.payment?.bolt11Invoice?.request ?: "",
             code = code,
@@ -498,11 +527,22 @@ data class BlocktankState(
 )
 
 sealed class GiftClaimResult {
-    object SuccessWithLiquidity : GiftClaimResult()
+    abstract val paymentHashOrTxId: String
+    abstract val sats: Long
+    abstract val invoice: String
+    abstract val code: String
+
+    data class SuccessWithLiquidity(
+        override val paymentHashOrTxId: String,
+        override val sats: Long,
+        override val invoice: String,
+        override val code: String,
+    ) : GiftClaimResult()
+
     data class SuccessWithoutLiquidity(
-        val paymentHashOrTxId: String,
-        val sats: Long,
-        val invoice: String,
-        val code: String,
+        override val paymentHashOrTxId: String,
+        override val sats: Long,
+        override val invoice: String,
+        override val code: String,
     ) : GiftClaimResult()
 }

app/src/main/java/to/bitkit/ui/sheets/GiftLoading.kt

@@ -34,12 +34,8 @@ import to.bitkit.ui.shared.util.gradientBackground
 import to.bitkit.ui.theme.Colors
 
 @Composable
-fun GiftLoading(
-    viewModel: GiftViewModel,
-) {
-    Content(
-        amount = viewModel.amount,
-    )
+fun GiftLoading(amount: ULong) {
+    Content(amount = amount)
 }
 
 @Composable

app/src/main/java/to/bitkit/ui/sheets/GiftSheet.kt

@@ -65,9 +65,7 @@ fun GiftSheet(
             startDestination = GiftRoute.Loading,
         ) {
             composableWithDefaultTransitions<GiftRoute.Loading> {
-                GiftLoading(
-                    viewModel = viewModel,
-                )
+                GiftLoading(amount = sheet.amount)
             }
             composableWithDefaultTransitions<GiftRoute.Used> {
                 GiftErrorSheet(

app/src/main/java/to/bitkit/ui/sheets/GiftViewModel.kt

@@ -59,66 +59,78 @@ class GiftViewModel @Inject constructor(
     }
 
     private suspend fun claimGift() = withContext(bgDispatcher) {
-        if (isClaiming) return@withContext
+        if (isClaiming) {
+            Logger.debug("Gift claim already in progress, skipping", context = TAG)
+            return@withContext
+        }
         isClaiming = true
 
         try {
+            Logger.debug("Claiming gift: code=$code, amount=$amount", context = TAG)
             blocktankRepo.claimGiftCode(
                 code = code,
                 amount = amount,
                 waitTimeout = NODE_STARTUP_TIMEOUT_MS.milliseconds,
             ).fold(
-                onSuccess = { result ->
-                    when (result) {
-                        is GiftClaimResult.SuccessWithLiquidity -> {
-                            _navigationEvent.emit(GiftRoute.Success)
-                        }
-                        is GiftClaimResult.SuccessWithoutLiquidity -> {
-                            insertGiftActivity(result)
-                            _successEvent.emit(
-                                NewTransactionSheetDetails(
-                                    type = NewTransactionSheetType.LIGHTNING,
-                                    direction = NewTransactionSheetDirection.RECEIVED,
-                                    paymentHashOrTxId = result.paymentHashOrTxId,
-                                    sats = result.sats,
-                                )
-                            )
-                            _navigationEvent.emit(GiftRoute.Success)
-                        }
+                onSuccess = {
+                    Logger.debug("Gift claim successful: $it", context = TAG)
+                    if (it is GiftClaimResult.SuccessWithoutLiquidity) {
+                        insertGiftActivity(it.paymentHashOrTxId, it.sats, it.invoice, it.code)
                     }
+                    _successEvent.emit(
+                        NewTransactionSheetDetails(
+                            type = NewTransactionSheetType.LIGHTNING,
+                            direction = NewTransactionSheetDirection.RECEIVED,
+                            paymentHashOrTxId = it.paymentHashOrTxId,
+                            sats = it.sats,
+                        )
+                    )
+                    _navigationEvent.emit(GiftRoute.Success)
                 },
-                onFailure = { error ->
-                    handleGiftClaimError(error)
-                }
+                onFailure = { handleGiftClaimError(it) },
             )
         } finally {
             isClaiming = false
         }
     }
 
-    private suspend fun insertGiftActivity(result: GiftClaimResult.SuccessWithoutLiquidity) {
+    private suspend fun insertGiftActivity(
+        paymentHashOrTxId: String,
+        sats: Long,
+        invoice: String,
+        code: String,
+    ) {
         val nowTimestamp = nowTimestamp().epochSecond.toULong()
 
         val lightningActivity = LightningActivity.create(
-            id = result.paymentHashOrTxId,
+            id = paymentHashOrTxId,
             txType = PaymentType.RECEIVED,
             status = PaymentState.SUCCEEDED,
-            value = result.sats.toULong(),
-            invoice = result.invoice,
+            value = sats.toULong(),
+            invoice = invoice,
             timestamp = nowTimestamp,
-            message = result.code,
+            message = code,
         )
 
         activityRepo.insertActivity(Activity.Lightning(lightningActivity)).getOrThrow()
     }
 
     private suspend fun handleGiftClaimError(error: Throwable) {
-        Logger.error("Gift claim failed: $error", error, context = TAG)
+        Logger.error("Gift claim failed", error, context = TAG)
 
         val route = when {
-            errorContains(error, "GIFT_CODE_ALREADY_USED") -> GiftRoute.Used
-            errorContains(error, "GIFT_CODE_USED_UP") -> GiftRoute.UsedUp
-            else -> GiftRoute.Error
+            errorContains(error, "GIFT_CODE_ALREADY_USED") -> {
+                Logger.info("Gift code was already used", context = TAG)
+                GiftRoute.Used
+            }
+            errorContains(error, "GIFT_CODE_USED_UP") -> {
+                Logger.info("Gift code promotion depleted", context = TAG)
+                GiftRoute.UsedUp
+            }
+            else -> {
+                Logger.error("Unhandled gift claim error type", error, context = TAG)
+                GiftRoute.Error
+            }
         }
 
         _navigationEvent.emit(route)

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

@@ -255,7 +255,14 @@ class AppViewModel @Inject constructor(
         viewModelScope.launch {
             timedSheetManager.currentSheet.collect { sheetType ->
                 if (sheetType != null) {
-                    showSheet(Sheet.TimedSheet(sheetType))
+                    val currentSheet = _currentSheet.value
+                    val isHighPrioritySheetShowing = currentSheet is Sheet.Gift ||
+                        currentSheet is Sheet.Send ||
+                        currentSheet is Sheet.LnurlAuth ||
+                        currentSheet is Sheet.Pin
+                    if (!isHighPrioritySheetShowing) {
+                        showSheet(Sheet.TimedSheet(sheetType))
+                    }
                 } else {
                     // Clear the timed sheet when manager sets it to null
                     _currentSheet.update { current ->