Merge branch 'master' into fix/migration-with-bad-connection

Author: ben-kaufman

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

README.md

@@ -153,6 +153,16 @@ To build the mainnet flavor for release run:
 ./gradlew assembleMainnetRelease
 ```
 
+#### Android App Bundle (AAB)
+
+For Play Store submission, build an AAB instead of APK:
+
+```sh
+./gradlew bundleMainnetRelease
+```
+
+AAB is generated in `app/build/outputs/bundle/mainnetRelease/`.
+
 ### Build for E2E Testing
 
 Pass `E2E=true` and build any flavor. By default, E2E uses a local Electrum override.

app/build.gradle.kts

@@ -37,7 +37,14 @@ val keystoreProperties by lazy {
     keystoreProperties
 }
 
-val locales = listOf("en", "ar", "ca", "cs", "de", "el", "es", "fr", "it", "nl", "pl", "pt", "ru")
+// Android resource qualifier format for androidResources.localeFilters
+val androidLocales = listOf(
+    "en", "ar", "b+es+419", "ca", "cs", "de", "el", "es", "es-rES", "fr", "it", "nl", "pl", "pt", "pt-rBR", "ru"
+)
+// BCP 47 format for BuildConfig.LOCALES (used with Locale.forLanguageTag())
+val bcp47Locales = listOf(
+    "en", "ar", "es-419", "ca", "cs", "de", "el", "es", "es-ES", "fr", "it", "nl", "pl", "pt", "pt-BR", "ru"
+)
 val e2eBackendEnv = System.getenv("E2E_BACKEND") ?: "local"
 
 android {
@@ -47,16 +54,16 @@ android {
         applicationId = "to.bitkit"
         minSdk = 28
         targetSdk = 36
-        versionCode = 170
-        versionName = "2.0.0-rc.4"
+        versionCode = 172
+        versionName = "2.0.0-rc.6"
         testInstrumentationRunner = "to.bitkit.test.HiltTestRunner"
         vectorDrawables {
             useSupportLibrary = true
         }
         buildConfigField("boolean", "E2E", System.getenv("E2E")?.toBoolean()?.toString() ?: "false")
         buildConfigField("String", "E2E_BACKEND", "\"$e2eBackendEnv\"")
         buildConfigField("boolean", "GEO", System.getenv("GEO")?.toBoolean()?.toString() ?: "true")
-        buildConfigField("String", "LOCALES", "\"${locales.joinToString(",")}\"")
+        buildConfigField("String", "LOCALES", "\"${bcp47Locales.joinToString(",")}\"")
     }
 
     flavorDimensions += "network"
@@ -146,7 +153,7 @@ android {
     }
     androidResources {
         @Suppress("UnstableApiUsage")
-        localeFilters.addAll(locales)
+        localeFilters.addAll(androidLocales)
         @Suppress("UnstableApiUsage")
         generateLocaleConfig = true
     }

app/src/main/AndroidManifest.xml

@@ -17,7 +17,6 @@
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.CAMERA" />
-    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
     <!-- Required for E2E tests connecting to local Electrum server (Android 16+) -->
@@ -146,13 +145,13 @@
              See https://goo.gl/l4GJaQ -->
         <meta-data
             android:name="com.google.firebase.messaging.default_notification_icon"
-            android:resource="@drawable/ic_notification" />
+            android:resource="@drawable/ic_bitkit_outlined" />
         <!-- Set color used with incoming notification messages.
              This is used when no color is set for the incoming notification message.
              See https://goo.gl/6BKBk7 -->
         <meta-data
             android:name="com.google.firebase.messaging.default_notification_color"
-            android:resource="@color/teal_200" />
+            android:resource="@color/brand" />
         <!-- Set default notifications channel for Firebase. -->
         <meta-data
             android:name="com.google.firebase.messaging.default_notification_channel_id"

app/src/main/java/to/bitkit/androidServices/LightningNodeService.kt

@@ -146,9 +146,8 @@ class LightningNodeService : Service() {
     override fun onDestroy() {
         Logger.debug("onDestroy", context = TAG)
         serviceScope.launch {
-            lightningRepo.stop().onSuccess {
-                serviceScope.cancel()
-            }
+            lightningRepo.stop()
+            serviceScope.cancel()
         }
         super.onDestroy()
     }

app/src/main/java/to/bitkit/env/Env.kt

@@ -43,7 +43,6 @@ internal object Env {
 
     const val FILE_PROVIDER_AUTHORITY = "${BuildConfig.APPLICATION_ID}.fileprovider"
     const val SUPPORT_EMAIL = "support@synonym.to"
-    const val DEFAULT_INVOICE_MESSAGE = "Bitkit"
     const val PIN_LENGTH = 4
     const val PIN_ATTEMPTS = 8
 

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

@@ -195,7 +195,7 @@ class BlocktankRepo @Inject constructor(
 
     suspend fun createCjit(
         amountSats: ULong,
-        description: String = Env.DEFAULT_INVOICE_MESSAGE,
+        description: String = "",
     ): Result<IcJitEntry> = withContext(bgDispatcher) {
         runCatching {
             if (coreService.isGeoBlocked()) throw ServiceError.GeoBlocked()
@@ -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/repositories/HealthRepo.kt

@@ -11,6 +11,7 @@ import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import org.lightningdevkit.ldknode.ChannelDetails
 import to.bitkit.data.CacheStore
 import to.bitkit.di.BgDispatcher
 import to.bitkit.models.BackupCategory
@@ -43,68 +44,80 @@ class HealthRepo @Inject constructor(
         observeBackupStatus()
     }
 
-    @Suppress("CyclomaticComplexMethod")
     private fun collectState() {
-        val internetHealthState = connectivityRepo.isOnline.map { connectivityState ->
-            when (connectivityState) {
-                ConnectivityState.CONNECTED -> HealthState.READY
-                ConnectivityState.CONNECTING -> HealthState.PENDING
-                ConnectivityState.DISCONNECTED -> HealthState.ERROR
-            }
-        }
+        val internetHealthState = connectivityRepo.isOnline.map { it.asHealth() }
 
         repoScope.launch {
             combine(
                 internetHealthState,
                 lightningRepo.lightningState,
             ) { internetHealth, lightningState ->
-                val isOnline = internetHealth == HealthState.READY
-                val nodeLifecycleState = lightningState.nodeLifecycleState
-
-                val nodeHealth = when {
-                    !isOnline -> HealthState.ERROR
-                    else -> nodeLifecycleState.asHealth()
-                }
-
-                val electrumHealth = when {
-                    !isOnline -> HealthState.ERROR
-                    nodeLifecycleState.isRunning() -> HealthState.READY
-                    nodeLifecycleState.canRun() -> HealthState.PENDING
-                    else -> HealthState.ERROR
-                }
-
-                val channelsHealth = when {
-                    !isOnline -> HealthState.ERROR
-                    else -> {
-                        val channels = lightningState.channels
-                        val hasOpenChannels = channels.any { it.isChannelReady }
-                        val hasPendingChannels = channels.any { !it.isChannelReady }
-
-                        when {
-                            hasOpenChannels -> HealthState.READY
-                            hasPendingChannels -> HealthState.PENDING
-                            else -> HealthState.ERROR
-                        }
-                    }
-                }
-
-                AppHealthState(
-                    internet = internetHealth,
-                    electrum = electrumHealth,
-                    node = nodeHealth,
-                    channels = channelsHealth,
-                )
+                computeHealthState(internetHealth, lightningState)
             }.collect { newHealthState ->
-                updateState { currentState ->
-                    newHealthState.copy(
-                        backups = currentState.backups,
-                        app = currentState.app,
+                updateState {
+                    it.copy(
+                        internet = newHealthState.internet,
+                        electrum = newHealthState.electrum,
+                        node = newHealthState.node,
+                        channels = newHealthState.channels,
                     )
                 }
             }
         }
     }
 
+    @Suppress("CyclomaticComplexMethod")
+    private fun computeHealthState(internetHealth: HealthState, lightningState: LightningState): AppHealthState {
+        val isOnline = internetHealth == HealthState.READY
+        val nodeLifecycleState = lightningState.nodeLifecycleState
+        val isSyncing = lightningState.isSyncingWallet
+        val hasSyncError = lightningState.lastSyncError != null
+
+        val nodeHealth = when {
+            !isOnline -> HealthState.ERROR
+            isSyncing -> HealthState.PENDING
+            hasSyncError && nodeLifecycleState.isRunning() -> HealthState.ERROR
+            else -> nodeLifecycleState.asHealth()
+        }
+
+        val electrumHealth = when {
+            !isOnline -> HealthState.ERROR
+            isSyncing -> HealthState.PENDING
+            hasSyncError && nodeLifecycleState.isRunning() -> HealthState.ERROR
+            nodeLifecycleState.isRunning() -> HealthState.READY
+            nodeLifecycleState.canRun() -> HealthState.PENDING
+            else -> HealthState.ERROR
+        }
+
+        val channelsHealth = when {
+            !isOnline -> HealthState.ERROR
+            else -> computeChannelsHealth(lightningState.channels)
+        }
+
+        return AppHealthState(
+            internet = internetHealth,
+            electrum = electrumHealth,
+            node = nodeHealth,
+            channels = channelsHealth,
+        )
+    }
+
+    private fun computeChannelsHealth(channels: List<ChannelDetails>): HealthState {
+        val hasOpenChannels = channels.any { it.isChannelReady }
+        val hasPendingChannels = channels.any { !it.isChannelReady }
+        return when {
+            hasOpenChannels -> HealthState.READY
+            hasPendingChannels -> HealthState.PENDING
+            else -> HealthState.ERROR
+        }
+    }
+
+    private fun ConnectivityState.asHealth() = when (this) {
+        ConnectivityState.CONNECTED -> HealthState.READY
+        ConnectivityState.CONNECTING -> HealthState.PENDING
+        ConnectivityState.DISCONNECTED -> HealthState.ERROR
+    }
+
     private fun observePaidOrdersState() {
         repoScope.launch {
             blocktankRepo.blocktankState.map { it.paidOrders }.distinctUntilChanged().collect { paidOrders ->