Merge branch 'master' into feat/mainnet-probe-devtools

Author: piotr-iohk

.github/workflows/e2e.yml

@@ -305,6 +305,7 @@ jobs:
       matrix:
         shard:
           - { name: multi_address_2_regtest, grep: "@multi_address_2" }
+          - { name: pubky_paykit, grep: "@pubky" }
 
     name: e2e-tests-staging - ${{ matrix.shard.name }}
 

CHANGELOG.md

@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+- Fix Spending and Savings screens scrolling behind top bar and add gradient fade effect #892
 
 ### Changed
 - Improve Pubky profile restore, contact editing, and contact routing flows #905
@@ -25,6 +26,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Show loading state on Spending tab when node is not running #875
 
 ### Added
+- Transfer from Savings button on empty Spending screen when savings balance exists #882
 - Pubky profile onboarding with contact sync, import, and editing #824
 - Lightning Connections empty state with onboarding screen #857
 - Unified PIN management screen (enable/disable/change in one place) #857

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

@@ -246,7 +246,7 @@ internal object Env {
 @Suppress("ConstPropertyName")
 object Defaults {
     /** Default Bolt11 invoice expiry in seconds. */
-    const val bolt11InvoiceExpirySeconds = 3_600u
+    const val bolt11ExpirySec = 86_400u
 
     /** Recommended transaction base fee in sats */
     const val recommendedBaseFee = 256u

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

@@ -20,13 +20,17 @@ import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
@@ -37,16 +41,19 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import org.lightningdevkit.ldknode.Bolt11Invoice
 import org.lightningdevkit.ldknode.ChannelDetails
+import org.lightningdevkit.ldknode.Event
 import to.bitkit.async.ServiceQueue
 import to.bitkit.data.CacheStore
 import to.bitkit.di.BgDispatcher
-import to.bitkit.env.Defaults
 import to.bitkit.env.Env
 import to.bitkit.ext.calculateRemoteBalance
 import to.bitkit.ext.nowTimestamp
 import to.bitkit.models.BlocktankBackupV1
 import to.bitkit.models.EUR
+import to.bitkit.models.msatCeilOf
 import to.bitkit.services.CoreService
 import to.bitkit.services.LightningService
 import to.bitkit.utils.Logger
@@ -57,6 +64,7 @@ import javax.inject.Named
 import javax.inject.Singleton
 import kotlin.math.ceil
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.hours
 import kotlin.time.Duration.Companion.seconds
 
 @Singleton
@@ -459,26 +467,52 @@ class BlocktankRepo @Inject constructor(
         }
     }
 
-    private suspend fun claimGiftCodeWithLiquidity(code: String, amount: ULong): GiftClaimResult {
+    private suspend fun claimGiftCodeWithLiquidity(code: String, amount: ULong): GiftClaimResult = coroutineScope {
         val invoice = lightningRepo.createInvoice(
             amountSats = null,
             description = "blocktank-gift-code:$code",
-            expirySeconds = Defaults.bolt11InvoiceExpirySeconds,
+            expirySeconds = 1.hours.inWholeSeconds.toUInt(),
         ).getOrThrow()
 
+        val expectedPaymentHash = Bolt11Invoice.fromStr(invoice).paymentHash()
+
         Logger.debug("Created invoice for gift code, requesting payment from LSP", context = TAG)
 
+        val paymentReceivedDeferred = async(start = CoroutineStart.UNDISPATCHED) {
+            lightningRepo.nodeEvents
+                .filterIsInstance<Event.PaymentReceived>()
+                .first { it.paymentHash == expectedPaymentHash }
+        }
+
         val giftResponse = ServiceQueue.CORE.background {
             giftPay(invoice = invoice)
         }
 
-        Logger.debug("Gift payment request completed: id=${giftResponse.id}", context = TAG)
+        Logger.debug(
+            "Gift payment request completed: id='${giftResponse.id}', awaiting LDK PaymentReceived",
+            context = TAG,
+        )
+
+        val paymentReceived = withTimeoutOrNull(GIFT_PAYMENT_RECEIVE_TIMEOUT) {
+            paymentReceivedDeferred.await()
+        }
+
+        if (paymentReceived == null) {
+            paymentReceivedDeferred.cancel()
+            throw ServiceError.GiftClaimPaymentNotReceived()
+        }
+
+        Logger.debug(
+            "Gift payment confirmed by LDK: hash='${paymentReceived.paymentHash}', " +
+                "amountMsat='${paymentReceived.amountMsat}'",
+            context = TAG,
+        )
+
+        val receivedSats = msatCeilOf(paymentReceived.amountMsat).toLong()
 
-        return GiftClaimResult.SuccessWithLiquidity(
-            paymentHashOrTxId = giftResponse.bolt11PaymentId ?: giftResponse.id,
-            sats = giftResponse.bolt11Payment?.paidSat?.toLong()
-                ?: giftResponse.appliedGiftCode?.giftSat?.toLong()
-                ?: amount.toLong(),
+        GiftClaimResult.SuccessWithLiquidity(
+            paymentHashOrTxId = paymentReceived.paymentHash,
+            sats = receivedSats.takeIf { it > 0 } ?: amount.toLong(),
             invoice = invoice,
             code = code,
         )
@@ -518,6 +552,7 @@ class BlocktankRepo @Inject constructor(
         private const val DEFAULT_SOURCE = "bitkit-android"
         private const val PEER_CONNECTION_DELAY_MS = 2_000L
         private val TIMEOUT_GIFT_CODE = 30.seconds
+        private val GIFT_PAYMENT_RECEIVE_TIMEOUT = 45.seconds
     }
 }
 

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

@@ -58,10 +58,12 @@ import to.bitkit.data.SettingsStore
 import to.bitkit.data.backup.VssBackupClientLdk
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.di.BgDispatcher
+import to.bitkit.env.Defaults
 import to.bitkit.env.Env
 import to.bitkit.ext.getSatsPerVByteFor
 import to.bitkit.ext.nowTimestamp
 import to.bitkit.ext.toPeerDetailsList
+import to.bitkit.ext.totalNextOutboundHtlcLimitSats
 import to.bitkit.models.ALL_ADDRESS_TYPE_STRINGS
 import to.bitkit.models.CoinSelectionPreference
 import to.bitkit.models.NATIVE_WITNESS_TYPES
@@ -93,6 +95,7 @@ import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
@@ -151,6 +154,10 @@ class LightningRepo @Inject constructor(
                         return@collect
                     }
 
+                    if (_lightningState.value.nodeLifecycleState.isRunning()) {
+                        connectToTrustedPeers()
+                    }
+
                     // Start retry loop if sync is failing
                     startSyncRetryLoopIfNeeded()
                 }
@@ -533,7 +540,11 @@ class LightningRepo @Inject constructor(
 
     private fun handleLdkEvent(event: Event) {
         when (event) {
-            is Event.ChannelPending, is Event.ChannelReady -> scope.launch { refreshChannelCache() }
+            is Event.ChannelPending, is Event.ChannelReady -> scope.launch {
+                refreshChannelCache()
+                syncState()
+            }
+
             is Event.ChannelClosed -> scope.launch { registerClosedChannel(event.channelId, event.reason) }
             else -> Unit
         }
@@ -917,7 +928,7 @@ class LightningRepo @Inject constructor(
     suspend fun createInvoice(
         amountSats: ULong? = null,
         description: String,
-        expirySeconds: UInt = 86_400u,
+        expirySeconds: UInt = Defaults.bolt11ExpirySec,
     ): Result<String> = executeWhenNodeRunning("createInvoice") {
         updateGeoBlockState()
         runCatching { lightningService.receive(amountSats, description, expirySeconds) }
@@ -926,7 +937,7 @@ class LightningRepo @Inject constructor(
     suspend fun createInvoiceMsats(
         amountMsats: ULong,
         description: String,
-        expirySeconds: UInt = 86_400u,
+        expirySeconds: UInt = Defaults.bolt11ExpirySec,
     ): Result<String> = executeWhenNodeRunning("createInvoiceMsats") {
         updateGeoBlockState()
         runCatching { lightningService.receiveMsats(amountMsats, description, expirySeconds) }
@@ -1009,15 +1020,69 @@ class LightningRepo @Inject constructor(
         }
     }
 
-    private suspend fun waitForUsableChannels() {
-        if (lightningService.channels?.any { it.isUsable } == true) return
+    suspend fun waitForUsableChannels() = withContext(bgDispatcher) {
+        var state = _lightningState.value
+        if (!state.nodeLifecycleState.canRun()) {
+            delayNoUsableChannelsFeedback()
+            return@withContext
+        }
+        if (state.hasUsableChannels()) return@withContext
+
+        state = waitForChannelsToLoadIfNeeded(state) ?: return@withContext
+        if (!state.nodeLifecycleState.canRun()) {
+            delayNoUsableChannelsFeedback()
+            return@withContext
+        }
+
+        if (state.channels.isEmpty()) {
+            if (state.nodeLifecycleState.isRunning()) {
+                syncState()
+                state = _lightningState.value
+            }
+
+            if (state.channels.isEmpty()) {
+                delayNoUsableChannelsFeedback()
+                return@withContext
+            }
+            if (state.hasUsableChannels()) return@withContext
+        }
 
         Logger.info("Waiting for usable channels before sending payment", context = TAG)
-        syncState()
 
-        withTimeoutOrNull(CHANNELS_USABLE_TIMEOUT_MS) {
-            _lightningState.first { state -> state.channels.any { it.isUsable } }
-        } ?: Logger.warn("Timeout waiting for usable channels", context = TAG)
+        val finalState = withTimeoutOrNull(CHANNELS_USABLE_TIMEOUT) {
+            _lightningState.first { it.shouldStopWaitingForUsableChannels() }
+        } ?: run {
+            Logger.warn("Timed out waiting for usable channels", context = TAG)
+            return@withContext
+        }
+
+        if (!finalState.nodeLifecycleState.canRun() || finalState.channels.isEmpty()) {
+            delayNoUsableChannelsFeedback()
+        }
+    }
+
+    private suspend fun waitForChannelsToLoadIfNeeded(state: LightningState): LightningState? {
+        if (state.channels.isNotEmpty() || state.nodeLifecycleState.isRunning()) return state
+
+        Logger.info("Waiting for node to load channels before sending payment", context = TAG)
+        return withTimeoutOrNull(CHANNELS_USABLE_TIMEOUT) {
+            _lightningState.first { it.shouldStopWaitingForLoadedChannels() }
+        } ?: run {
+            Logger.warn("Timed out waiting for node to load channels", context = TAG)
+            null
+        }
+    }
+
+    private fun LightningState.hasUsableChannels() = channels.any { it.isUsable }
+
+    private fun LightningState.shouldStopWaitingForLoadedChannels() =
+        !nodeLifecycleState.canRun() || nodeLifecycleState.isRunning() || channels.isNotEmpty()
+
+    private fun LightningState.shouldStopWaitingForUsableChannels() =
+        !nodeLifecycleState.canRun() || channels.isEmpty() || hasUsableChannels()
+
+    private suspend fun delayNoUsableChannelsFeedback() {
+        delay(NO_USABLE_CHANNELS_FEEDBACK_DELAY)
     }
 
     @Suppress("LongParameterList")
@@ -1229,19 +1294,20 @@ class LightningRepo @Inject constructor(
         }
     }
 
-    suspend fun canSend(amountSats: ULong, fallbackToCachedBalance: Boolean = true) = withContext(bgDispatcher) {
-        if (!_lightningState.value.nodeLifecycleState.canRun()) {
-            return@withContext false
-        }
-        if (_lightningState.value.nodeLifecycleState.isStarting() && fallbackToCachedBalance) {
-            return@withContext amountSats <= (cacheStore.data.first().balance?.maxSendLightningSats ?: 0u)
-        }
-        if (lightningService.channels == null) {
-            withTimeoutOrNull(CHANNELS_READY_TIMEOUT_MS) {
-                _lightningState.first { lightningService.channels != null }
+    suspend fun awaitPeerConnected(timeout: Duration = 30.seconds) = withContext(bgDispatcher) {
+        if (lightningService.peers?.any { it.isConnected } == true) return@withContext
+        Logger.debug("Waiting for peer to reconnect (timeout='$timeout')...", context = TAG)
+        withTimeoutOrNull(timeout) {
+            while (lightningService.peers?.any { it.isConnected } != true) {
+                delay(1.seconds)
             }
         }
-        return@withContext lightningService.canSend(amountSats)
+    }
+
+    fun canSend(amountSats: ULong): Boolean {
+        val state = _lightningState.value
+        if (!state.nodeLifecycleState.canRun()) return false
+        return state.channels.totalNextOutboundHtlcLimitSats() >= amountSats
     }
 
     fun getNodeId(): String? =
@@ -1478,8 +1544,8 @@ class LightningRepo @Inject constructor(
         private const val LENGTH_CHANNEL_ID_PREVIEW = 10
         private const val MS_SYNC_LOOP_DEBOUNCE = 500L
         private const val SYNC_RETRY_DELAY_MS = 15_000L
-        private const val CHANNELS_READY_TIMEOUT_MS = 15_000L
-        private const val CHANNELS_USABLE_TIMEOUT_MS = 15_000L
+        private val CHANNELS_USABLE_TIMEOUT = 15.seconds
+        private val NO_USABLE_CHANNELS_FEEDBACK_DELAY = 2_500.milliseconds
         val SEND_LN_TIMEOUT = 10.seconds
         private val PROBE_TIMEOUT = 60.seconds
     }

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

@@ -70,6 +70,7 @@ import org.lightningdevkit.ldknode.TransactionDetails
 import to.bitkit.async.ServiceQueue
 import to.bitkit.data.CacheStore
 import to.bitkit.data.SettingsStore
+import to.bitkit.env.Defaults
 import to.bitkit.env.Env
 import to.bitkit.ext.amountSats
 import to.bitkit.ext.channelId
@@ -1523,11 +1524,15 @@ class BlocktankService(
         )
     }
 
-    suspend fun regtestCloseChannel(fundingTxId: String, vout: UInt, forceCloseAfterS: ULong = 86_400uL): String {
+    suspend fun regtestCloseChannel(
+        fundingTxId: String,
+        vout: UInt,
+        forceCloseAfterS: UInt = Defaults.bolt11ExpirySec,
+    ): String {
         return com.synonym.bitkitcore.regtestCloseChannel(
             fundingTxId = fundingTxId,
             vout = vout,
-            forceCloseAfterS = forceCloseAfterS,
+            forceCloseAfterS = forceCloseAfterS.toULong(),
         )
     }
 }