Merge branch 'feat/system-widgets-foundation' into feat/price-widget-v61

Author: jvsena42

.claude/commands/release.md

@@ -53,18 +53,9 @@ If "Previous tag": ask `"Which tag?"` with a text input (default: `v{oldVersionN
 
 If "master" or if the release is minor/major: `{baseRef} = master`.
 
-### 2c. Finalize Changelog
-
-Read `CHANGELOG.md` and check whether `## [Unreleased]` has any entries beneath it.
-
-**If entries exist:**
-1. Replace `## [Unreleased]` with `## [{newVersionName}] - {YYYY-MM-DD}` (today's date)
-2. Insert a fresh empty `## [Unreleased]` section above the new version heading
-3. Update the compare link references at the bottom of the file:
-   - Change `[Unreleased]` link to compare from `v{newVersionName}...HEAD`
-   - Add a new `[{newVersionName}]` link comparing `v{oldVersionName}...v{newVersionName}`
-
-**If no entries:** Print `⚠ CHANGELOG.md has no unreleased entries — continuing without changelog update.` and proceed.
+Set `{changelogTarget}`:
+- If `{baseRef}` is `master`: `next`
+- Otherwise: `hotfix`
 
 ### 3. Create Release Branch & Bump Version
 
@@ -86,18 +77,34 @@ Cherry-pick the commits you need onto this branch now, then continue.
 ```
 Wait for the user to confirm they are done cherry-picking before proceeding.
 
+Finalize changelog after the release branch contains all release commits:
+
+```bash
+scripts/collect-changelog.sh --target {changelogTarget}
+```
+
+Read `CHANGELOG.md` and check whether `## [Unreleased]` has any entries beneath it after collecting fragments.
+
+**If entries exist:**
+1. Replace `## [Unreleased]` with `## [{newVersionName}] - {YYYY-MM-DD}` (today's date)
+2. Insert a fresh empty `## [Unreleased]` section above the new version heading
+3. Update the compare link references at the bottom of the file:
+   - Change `[Unreleased]` link to compare from `v{newVersionName}...HEAD`
+   - Add a new `[{newVersionName}]` link comparing `v{oldVersionName}...v{newVersionName}`
+
+**If no entries:** Print `⚠ CHANGELOG.md has no unreleased entries — continuing without changelog update.` and proceed.
+
 Edit `app/build.gradle.kts`:
 - Change `versionCode = {old}` to `versionCode = {newVersionCode}`
 - Change `versionName = "{old}"` to `versionName = "{newVersionName}"`
 
 ```bash
 git add app/build.gradle.kts
-# Only stage CHANGELOG.md if step 2c modified it (i.e. unreleased entries were found)
 git commit -m "chore: version {newVersionName}"
 git push -u origin release-{newVersionName}
 ```
 
-If step 2c updated `CHANGELOG.md`, also `git add CHANGELOG.md` before the commit.
+If changelog collection updated `CHANGELOG.md` or deleted consumed fragments, run `git add CHANGELOG.md changelog.d` before the commit.
 
 ### 4. Create Version Bump PR
 

.cursor/rules/rules.main.mdc

@@ -63,12 +63,14 @@ alwaysApply: true
 ---
 
 ## Changelog rules:
-- add an entry under `## [Unreleased]` in `CHANGELOG.md` for `feat:` and `fix:` PRs; skip for `chore:`, `ci:`, `refactor:`, `test:`, `docs:` unless the change is user-facing
-- use standard Keep a Changelog categories: `### Added`, `### Changed`, `### Deprecated`, `### Removed`, `### Fixed`, `### Security`
-- append `#PR_NUMBER` at the end of each changelog entry when the PR number is known
-- place new entries at the top of their category section (newest first)
-- never modify released version sections — only edit `## [Unreleased]`
-- create category headings on demand (don't add empty stubs)
+- never edit `CHANGELOG.md` in normal feature/fix PRs; release automation collects changelog fragments into it
+- add exactly one changelog fragment for user-facing `feat:` and `fix:` PRs; skip for `chore:`, `ci:`, `refactor:`, `test:`, `docs:` unless the change is user-facing
+- put normal release fragments in `changelog.d/next/` and hotfix fragments in `changelog.d/hotfix/`
+- name fragments `<issue-or-pr>.<category>.md`, where category is one of `added`, `changed`, `deprecated`, `removed`, `fixed`, or `security`
+- write the fragment as one polished user-facing sentence without a leading bullet and without a PR number
+- never add multiple changelog fragments for the same PR — summarize all changes in one concise fragment
+- release commits consume fragments with `scripts/collect-changelog.sh --target next|hotfix`, update `CHANGELOG.md`, and delete consumed fragment files
+- never modify released version sections manually
 
 ---
 

.github/pull_request_template.md

@@ -1,5 +1,5 @@
 <!-- Closes | Fixes | Resolves #ISSUE_ID -->
-<!-- Changelog: Add an entry under ## [Unreleased] in CHANGELOG.md for user-facing changes (skip for chores/CI/refactors). -->
+<!-- Changelog: For user-facing changes, add one fragment in changelog.d/next/ or changelog.d/hotfix/. Do not edit CHANGELOG.md in normal PRs. -->
 <!-- Brief summary of the PR changes, linking to the related resources (issue/design/bug/etc) if applicable. -->
 
 ### Description

AGENTS.md

@@ -240,13 +240,14 @@ suspend fun getData(): Result<Data> = withContext(Dispatchers.IO) {
 
 ### Changelog
 
-- ALWAYS add exactly ONE entry per PR under `## [Unreleased]` in `CHANGELOG.md` for `feat:` and `fix:` PRs; skip for `chore:`, `ci:`, `refactor:`, `test:`, `docs:` unless the change is user-facing
-- NEVER add multiple changelog lines for the same PR — summarize all changes in a single concise entry
-- USE standard Keep a Changelog categories: `### Added`, `### Changed`, `### Deprecated`, `### Removed`, `### Fixed`, `### Security`
-- ALWAYS append `#PR_NUMBER` at the end of each changelog entry when the PR number is known
-- ALWAYS place new entries at the top of their category section (newest first)
-- NEVER modify released version sections — only edit `## [Unreleased]`
-- ALWAYS create category headings on demand (don't add empty stubs)
+- NEVER edit `CHANGELOG.md` in normal feature/fix PRs; release automation collects changelog fragments into it
+- ALWAYS add exactly ONE changelog fragment for user-facing `feat:` and `fix:` PRs; skip for `chore:`, `ci:`, `refactor:`, `test:`, `docs:` unless the change is user-facing
+- PUT normal release fragments in `changelog.d/next/` and hotfix fragments in `changelog.d/hotfix/`
+- NAME fragments `<issue-or-pr>.<category>.md`, where category is one of `added`, `changed`, `deprecated`, `removed`, `fixed`, or `security`
+- WRITE the fragment as one polished user-facing sentence without a leading bullet and without a PR number
+- NEVER add multiple changelog fragments for the same PR — summarize all changes in one concise fragment
+- Release commits consume fragments with `scripts/collect-changelog.sh --target next|hotfix`, update `CHANGELOG.md`, and delete consumed fragment files
+- NEVER modify released version sections manually
 
 ### Device Debugging (adb)
 

CHANGELOG.md

@@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Improve Pubky profile restore, contact editing, and contact routing flows #905
 
 ### Fixed
+- Fix probe results and add keysend probes #920
+- Align top bar back arrow and passphrase input cursor/placeholder with iOS #906
 - Polish Terms of Use screen padding to match iOS #903
 
 ### Added

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

@@ -17,6 +17,10 @@ value class USat(val value: ULong) : Comparable<USat> {
     /** Saturating addition: caps at ULong.MAX_VALUE if result would overflow. */
     operator fun plus(other: USat): ULong =
         if (value <= ULong.MAX_VALUE - other.value) value + other.value else ULong.MAX_VALUE
+
+    /** Saturating multiplication: caps at ULong.MAX_VALUE if result would overflow. */
+    operator fun times(other: USat): ULong =
+        if (other.value == 0uL || value <= ULong.MAX_VALUE / other.value) value * other.value else ULong.MAX_VALUE
 }
 
 /**

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

@@ -24,8 +24,11 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.onSubscription
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
@@ -44,6 +47,7 @@ import org.lightningdevkit.ldknode.ClosureReason
 import org.lightningdevkit.ldknode.Event
 import org.lightningdevkit.ldknode.NodeStatus
 import org.lightningdevkit.ldknode.PaymentDetails
+import org.lightningdevkit.ldknode.PaymentHash
 import org.lightningdevkit.ldknode.PaymentId
 import org.lightningdevkit.ldknode.PeerDetails
 import org.lightningdevkit.ldknode.SpendableUtxo
@@ -60,6 +64,7 @@ import to.bitkit.ext.nowTimestamp
 import to.bitkit.ext.toPeerDetailsList
 import to.bitkit.models.ALL_ADDRESS_TYPE_STRINGS
 import to.bitkit.models.CoinSelectionPreference
+import to.bitkit.models.MSat
 import to.bitkit.models.NATIVE_WITNESS_TYPES
 import to.bitkit.models.NodeLifecycleState
 import to.bitkit.models.OpenChannelResult
@@ -121,6 +126,8 @@ class LightningRepo @Inject constructor(
     val isRecoveryMode = _isRecoveryMode.asStateFlow()
 
     private val channelCache = ConcurrentHashMap<String, ChannelDetails>()
+    private val probeOutcomeCache = ConcurrentHashMap<PaymentId, ProbeOutcome>()
+    private val probeOutcomeSignal = MutableSharedFlow<ProbeOutcome>(extraBufferCapacity = 64)
 
     private val syncMutex = Mutex()
     private val syncPending = AtomicBoolean(false)
@@ -420,6 +427,7 @@ class LightningRepo @Inject constructor(
 
     private suspend fun onEvent(event: Event) {
         handleLdkEvent(event)
+        recordProbeOutcome(event)
         _eventHandlers.toList().forEach {
             runCatching { it.invoke(event) }
         }
@@ -441,12 +449,14 @@ class LightningRepo @Inject constructor(
     suspend fun stop(): Result<Unit> = withContext(bgDispatcher) {
         lifecycleMutex.withLock {
             if (_lightningState.value.nodeLifecycleState.isStoppedOrStopping()) {
+                clearProbeOutcomes()
                 return@withLock Result.success(Unit)
             }
 
             runCatching {
                 _lightningState.update { it.copy(nodeLifecycleState = NodeLifecycleState.Stopping) }
                 lightningService.stop()
+                clearProbeOutcomes()
                 _lightningState.update { LightningState(nodeLifecycleState = NodeLifecycleState.Stopped) }
             }.onFailure {
                 Logger.error("Node stop error", it, context = TAG)
@@ -529,6 +539,21 @@ class LightningRepo @Inject constructor(
         }
     }
 
+    private suspend fun recordProbeOutcome(event: Event) {
+        val outcome = when (event) {
+            is Event.ProbeSuccessful -> ProbeOutcome.Success(event.paymentId, event.paymentHash)
+            is Event.ProbeFailed -> ProbeOutcome.Failure(event.paymentId, event.paymentHash, event.shortChannelId)
+            else -> return
+        }
+
+        probeOutcomeCache[outcome.paymentId] = outcome
+        probeOutcomeSignal.emit(outcome)
+    }
+
+    private fun clearProbeOutcomes() {
+        probeOutcomeCache.clear()
+    }
+
     private suspend fun registerClosedChannel(channelId: String, reason: ClosureReason?) = withContext(bgDispatcher) {
         runCatching {
             val channel = channelCache[channelId] ?: run {
@@ -582,6 +607,7 @@ class LightningRepo @Inject constructor(
         stop().mapCatching {
             Logger.debug("node stopped, calling wipeStorage", context = TAG)
             lightningService.wipeStorage(walletIndex)
+            clearProbeOutcomes()
             _lightningState.update {
                 LightningState(
                     nodeStatus = it.nodeStatus,
@@ -1363,23 +1389,74 @@ class LightningRepo @Inject constructor(
     // endregion
 
     // region probing
-    suspend fun sendProbeForInvoice(bolt11: String, amountSats: ULong? = null): Result<Unit> =
+    suspend fun sendProbeForInvoice(bolt11: String, amountSats: ULong? = null): Result<ProbeDispatch> =
         executeWhenNodeRunning("sendProbeForInvoice") {
             Logger.debug(
-                "sendProbeForInvoice: amountSats=${amountSats ?: "null (using invoice amount)"}",
-                context = TAG
+                "sendProbeForInvoice: amountSats='${amountSats ?: "null (using invoice amount)"}'",
+                context = TAG,
             )
-            runCatching {
-                if (amountSats != null) {
-                    val amountMsat = amountSats * 1000u
-                    lightningService.sendProbesUsingAmount(bolt11, amountMsat)
-                } else {
-                    lightningService.sendProbes(bolt11)
-                }
-            }.getOrElse {
-                Result.failure(it)
+            val result = if (amountSats != null) {
+                val amountMsat = amountSats.safe() * MSat.PER_SAT.safe()
+                lightningService.sendProbesUsingAmount(bolt11, amountMsat)
+            } else {
+                lightningService.sendProbes(bolt11)
             }
+
+            result.map { ProbeDispatch(paymentIds = it) }
         }
+
+    suspend fun sendProbeForNode(nodeId: String, amountSats: ULong): Result<ProbeDispatch> =
+        executeWhenNodeRunning("sendProbeForNode") {
+            Logger.debug(
+                "Sending keysend probe to nodeId='$nodeId' amountSats='$amountSats'",
+                context = TAG,
+            )
+            val amountMsat = amountSats.safe() * MSat.PER_SAT.safe()
+            lightningService.sendKeysendProbe(nodeId, amountMsat).map {
+                ProbeDispatch(paymentIds = it)
+            }
+        }
+
+    suspend fun waitForProbeOutcome(
+        paymentIds: Set<PaymentId>,
+        timeout: Duration = PROBE_TIMEOUT,
+    ): Result<ProbeOutcome> = withContext(bgDispatcher) {
+        if (paymentIds.isEmpty()) {
+            return@withContext Result.failure(ProbeError.NoProbeHandles())
+        }
+
+        val trackedIds = paymentIds.toSet()
+        val outcome = withTimeoutOrNull(timeout) {
+            val pending = trackedIds.toMutableSet()
+            var lastFailure: ProbeOutcome.Failure? = null
+
+            probeOutcomeSignal
+                .onSubscription {
+                    trackedIds.forEach { id ->
+                        probeOutcomeCache[id]?.let { emit(it) }
+                    }
+                }
+                .filter { it.paymentId in trackedIds }
+                .mapNotNull { probeOutcome ->
+                    if (!pending.remove(probeOutcome.paymentId)) return@mapNotNull null
+
+                    probeOutcomeCache.remove(probeOutcome.paymentId)
+                    when (probeOutcome) {
+                        is ProbeOutcome.Success -> probeOutcome
+                        is ProbeOutcome.Failure -> {
+                            lastFailure = probeOutcome
+                            if (pending.isEmpty()) lastFailure else null
+                        }
+                    }
+                }
+                .first()
+        }
+
+        trackedIds.forEach { probeOutcomeCache.remove(it) }
+
+        outcome?.let { Result.success(it) }
+            ?: Result.failure(ProbeError.TimedOut())
+    }
     // endregion
 
     suspend fun restartNode(): Result<Unit> = withContext(bgDispatcher) {
@@ -1404,6 +1481,7 @@ class LightningRepo @Inject constructor(
         private const val CHANNELS_READY_TIMEOUT_MS = 15_000L
         private const val CHANNELS_USABLE_TIMEOUT_MS = 15_000L
         val SEND_LN_TIMEOUT = 10.seconds
+        private val PROBE_TIMEOUT = 60.seconds
     }
 }
 
@@ -1413,6 +1491,10 @@ class NodeStopTimeoutError : AppError("Timeout waiting for node to stop")
 class NodeRunTimeoutError(opName: String) : AppError("Timeout waiting for node to run and execute: '$opName'")
 class GetPaymentsError : AppError("It wasn't possible get the payments")
 class SyncUnhealthyError : AppError("Wallet sync failed before send")
+sealed class ProbeError(message: String) : AppError(message) {
+    class NoProbeHandles : ProbeError("No probe handles returned")
+    class TimedOut : ProbeError("Probe timed out")
+}
 
 @Stable
 data class LightningState(
@@ -1436,3 +1518,23 @@ data class LightningState(
     val isSyncHealthy: Boolean
         get() = lastSyncError == null && lastSuccessfulSyncAt != null
 }
+
+data class ProbeDispatch(
+    val paymentIds: Set<PaymentId>,
+)
+
+sealed interface ProbeOutcome {
+    val paymentId: PaymentId
+    val paymentHash: PaymentHash
+
+    data class Success(
+        override val paymentId: PaymentId,
+        override val paymentHash: PaymentHash,
+    ) : ProbeOutcome
+
+    data class Failure(
+        override val paymentId: PaymentId,
+        override val paymentHash: PaymentHash,
+        val shortChannelId: ULong?,
+    ) : ProbeOutcome
+}