LNURL Pay and Lightning Address

.editorconfig

@@ -11,7 +11,7 @@ trim_trailing_whitespace = true
 
 [*.{kt,kts}]
 ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true
+# ij_kotlin_allow_trailing_comma_on_call_site = true
 ktlint_code_style = android_studio
 ktlint_experimental = enabled
 ktlint_function_naming_ignore_when_annotated_with = Composable

app/src/main/java/to/bitkit/ext/ChannelDetails.kt

@@ -15,6 +15,22 @@ val ChannelDetails.amountOnClose: ULong
         return outboundCapacitySat + reserveSats
     }
 
+/** Returns only `open` channels, filtering out pending ones. */
+fun List<ChannelDetails>.filterOpen(): List<ChannelDetails> {
+    return this.filter { it.isChannelReady }
+}
+
+/** Returns only `pending` channels. */
+fun List<ChannelDetails>.filterPending(): List<ChannelDetails> {
+    return this.filterNot { it.isChannelReady }
+}
+
+/** Returns a limit in sats as close as possible to the HTLC limit we can currently send. */
+fun List<ChannelDetails>.totalNextOutboundHtlcLimitSats(): ULong {
+    return this.filter { it.isUsable }
+        .sumOf { it.nextOutboundHtlcLimitMsat / 1000uL }
+}
+
 fun createChannelDetails(): ChannelDetails {
     return ChannelDetails(
         channelId = "channelId",

app/src/main/java/to/bitkit/ext/Lnurl.kt

@@ -0,0 +1,10 @@
+package to.bitkit.ext
+
+import com.synonym.bitkitcore.LnurlPayData
+import com.synonym.bitkitcore.LnurlWithdrawData
+
+fun LnurlPayData.commentAllowed(): Boolean = commentAllowed?.let { it > 0u } == true
+fun LnurlPayData.maxSendableSat(): ULong = maxSendable / 1000u
+fun LnurlPayData.minSendableSat(): ULong = minSendable / 1000u
+
+fun LnurlWithdrawData.maxWithdrawableSat(): ULong = maxWithdrawable / 1000u

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

@@ -6,5 +6,6 @@ import kotlinx.serialization.Serializable
 data class BalanceState(
     val totalOnchainSats: ULong = 0uL,
     val totalLightningSats: ULong = 0uL,
+    val maxSendLightningSats: ULong = 0uL, // TODO use where applicable
     val totalSats: ULong = 0uL,
 )

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

@@ -3,12 +3,14 @@ package to.bitkit.models
 import kotlinx.datetime.Instant
 import kotlinx.serialization.Serializable
 import java.math.BigDecimal
+import java.math.RoundingMode
 import java.text.DecimalFormat
 import java.text.DecimalFormatSymbols
 import java.util.Locale
 
 const val BITCOIN_SYMBOL = "₿"
 const val SATS_IN_BTC = 100_000_000
+const val BTC_SCALE = 8
 const val BTC_PLACEHOLDER = "0.00000000"
 const val SATS_PLACEHOLDER = "0"
 
@@ -54,7 +56,7 @@ data class ConvertedAmount(
     val flag: String,
     val sats: Long,
 ) {
-    val btcValue: BigDecimal = BigDecimal(sats).divide(BigDecimal(SATS_IN_BTC))
+    val btcValue: BigDecimal = sats.asBtc()
 
     data class BitcoinDisplayComponents(
         val symbol: String,
@@ -96,3 +98,6 @@ fun Long.formatToModernDisplay(): String {
 }
 
 fun ULong.formatToModernDisplay(): String = this.toLong().formatToModernDisplay()
+
+/** Represent this sat value in Bitcoin BigDecimal. */
+fun Long.asBtc(): BigDecimal = BigDecimal(this).divide(BigDecimal(SATS_IN_BTC), BTC_SCALE, RoundingMode.HALF_UP)

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

@@ -23,12 +23,14 @@ import to.bitkit.data.CacheStore
 import to.bitkit.data.SettingsStore
 import to.bitkit.di.BgDispatcher
 import to.bitkit.env.Env
+import to.bitkit.models.BTC_SCALE
 import to.bitkit.models.BitcoinDisplayUnit
 import to.bitkit.models.ConvertedAmount
 import to.bitkit.models.FxRate
 import to.bitkit.models.PrimaryDisplay
 import to.bitkit.models.SATS_IN_BTC
 import to.bitkit.models.Toast
+import to.bitkit.models.asBtc
 import to.bitkit.services.CurrencyService
 import to.bitkit.ui.shared.toast.ToastEventBus
 import to.bitkit.ui.utils.formatCurrency
@@ -196,16 +198,16 @@ class CurrencyRepo @Inject constructor(
             )
         )
 
-        val btcAmount = BigDecimal(sats).divide(BigDecimal(SATS_IN_BTC), BTC_SCALE, RoundingMode.HALF_UP)
-        val value = btcAmount.multiply(BigDecimal.valueOf(rate.rate))
-        val formatted = value.formatCurrency() ?: return Result.failure(
+        val btcAmount = sats.asBtc()
+        val fiatValue = btcAmount.multiply(BigDecimal.valueOf(rate.rate))
+        val formatted = fiatValue.formatCurrency() ?: return Result.failure(
             IllegalStateException(
-                "Failed to format value: $value for currency: $targetCurrency"
+                "Failed to format value: $fiatValue for currency: $targetCurrency"
             )
         )
 
         ConvertedAmount(
-            value = value,
+            value = fiatValue,
             formatted = formatted,
             symbol = rate.currencySymbol,
             currency = rate.quote,
@@ -243,7 +245,6 @@ class CurrencyRepo @Inject constructor(
 
     companion object {
         private const val TAG = "CurrencyRepo"
-        private const val BTC_SCALE = 8
     }
 }
 

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

@@ -1,8 +1,10 @@
 package to.bitkit.repositories
 
-import android.net.Uri
 import com.google.firebase.messaging.FirebaseMessaging
+import com.synonym.bitkitcore.LightningInvoice
+import com.synonym.bitkitcore.Scanner
 import com.synonym.bitkitcore.createWithdrawCallbackUrl
+import com.synonym.bitkitcore.decode
 import com.synonym.bitkitcore.getLnurlInvoice
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.delay
@@ -39,7 +41,7 @@ import to.bitkit.services.CoreService
 import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.services.LightningService
 import to.bitkit.services.LnUrlWithdrawResponse
-import to.bitkit.services.LnUrlWithdrawService
+import to.bitkit.services.LnurlService
 import to.bitkit.services.NodeEventHandler
 import to.bitkit.utils.Logger
 import to.bitkit.utils.ServiceError
@@ -59,7 +61,7 @@ class LightningRepo @Inject constructor(
     private val blocktankNotificationsService: BlocktankNotificationsService,
     private val firebaseMessaging: FirebaseMessaging,
     private val keychain: Keychain,
-    private val lnUrlWithdrawService: LnUrlWithdrawService,
+    private val lnurlService: LnurlService,
     private val cacheStore: CacheStore,
 ) {
     private val _lightningState = MutableStateFlow(LightningState())
@@ -401,12 +403,19 @@ class LightningRepo @Inject constructor(
         Result.success(invoice)
     }
 
-    suspend fun createLnurlInvoice(
-        address: String,
-        amountSatoshis: ULong,
-    ): Result<String> = executeWhenNodeRunning("getLnUrlInvoice") {
-        val invoice = getLnurlInvoice(address, amountSatoshis)
-        Result.success(invoice)
+    suspend fun fetchLnurlInvoice(
+        callbackUrl: String,
+        amountSats: ULong,
+        comment: String? = null,
+    ): Result<LightningInvoice> {
+        return runCatching {
+            // TODO use bitkit-core getLnurlInvoice if it works with callbackUrl
+            val bolt11 = lnurlService.fetchLnurlInvoice(callbackUrl, amountSats, comment).pr
+            val decoded = (decode(bolt11) as Scanner.Lightning).invoice
+            return@runCatching decoded
+        }.onFailure {
+            Logger.error("Error fetching lnurl invoice, url: $callbackUrl, amount: $amountSats, comment: $comment", it)
+        }
     }
 
     suspend fun handleLnUrlWithdraw(
@@ -416,40 +425,7 @@ class LightningRepo @Inject constructor(
     ): Result<LnUrlWithdrawResponse> = executeWhenNodeRunning("create LnUrl withdraw callback") {
         val callbackUrl = createWithdrawCallbackUrl(k1 = k1, callback = callback, paymentRequest = paymentRequest)
         Logger.debug("handleLnUrlWithdraw callbackUrl generated:$callbackUrl")
-        val formattedCallbackUrl = callbackUrl.removeDuplicateQueryParams()
-        Logger.debug("handleLnUrlWithdraw formatted callbackUrl:$formattedCallbackUrl")
-        lnUrlWithdrawService.fetchWithdrawInfo(formattedCallbackUrl)
-    }
-
-    /**
-     * Extension function to remove duplicate query parameters from a URL string
-     * Keeps the first occurrence of each parameter
-     */
-    private fun String.removeDuplicateQueryParams(): String { // TODO REMOVE AFTER CORE FIX
-        return try {
-            val uri = Uri.parse(this)
-            val builder = uri.buildUpon().clearQuery()
-
-            // Track seen parameters to avoid duplicates
-            val seenParams = mutableSetOf<String>()
-
-            // Get all query parameter names
-            uri.queryParameterNames.forEach { paramName ->
-                if (!seenParams.contains(paramName)) {
-                    // Add only the first occurrence of each parameter
-                    val value = uri.getQueryParameter(paramName)
-                    if (value != null) {
-                        builder.appendQueryParameter(paramName, value)
-                        seenParams.add(paramName)
-                    }
-                }
-            }
-
-            builder.build().toString()
-        } catch (e: Exception) {
-            // Return original string if parsing fails
-            this
-        }
+        lnurlService.fetchWithdrawInfo(callbackUrl)
     }
 
     suspend fun payInvoice(bolt11: String, sats: ULong? = null): Result<PaymentId> =

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

@@ -25,6 +25,7 @@ import to.bitkit.data.keychain.Keychain
 import to.bitkit.di.BgDispatcher
 import to.bitkit.env.Env
 import to.bitkit.ext.toHex
+import to.bitkit.ext.totalNextOutboundHtlcLimitSats
 import to.bitkit.models.AddressModel
 import to.bitkit.models.BalanceState
 import to.bitkit.models.NodeLifecycleState
@@ -162,6 +163,7 @@ class WalletRepo @Inject constructor(
             val newBalance = BalanceState(
                 totalOnchainSats = balance.totalOnchainBalanceSats,
                 totalLightningSats = balance.totalLightningBalanceSats,
+                maxSendLightningSats = lightningRepo.getChannels()?.totalNextOutboundHtlcLimitSats() ?: 0u,
                 totalSats = totalSats,
             )
             _balanceState.update { newBalance }

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

@@ -341,7 +341,7 @@ class ActivityService(
                                 value = payment.amountSats ?: 0u,
                                 fee = (payment.feePaidMsat ?: 0u) / 1000u,
                                 invoice = "lnbc123_todo", // TODO
-                                message = "",
+                                message = kind.description.orEmpty(),
                                 timestamp = payment.latestUpdateTimestamp,
                                 preimage = kind.preimage,
                                 createdAt = payment.latestUpdateTimestamp,

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

@@ -41,6 +41,7 @@ import to.bitkit.data.keychain.Keychain
 import to.bitkit.di.BgDispatcher
 import to.bitkit.env.Env
 import to.bitkit.ext.DatePattern
+import to.bitkit.ext.totalNextOutboundHtlcLimitSats
 import to.bitkit.ext.uByteList
 import to.bitkit.models.ElectrumServer
 import to.bitkit.models.LnPeer
@@ -390,9 +391,7 @@ class LightningService @Inject constructor(
             return false
         }
 
-        val totalNextOutboundHtlcLimitSats = channels
-            .filter { it.isUsable }
-            .sumOf { it.nextOutboundHtlcLimitMsat / 1000uL }
+        val totalNextOutboundHtlcLimitSats = channels.totalNextOutboundHtlcLimitSats()
 
         if (totalNextOutboundHtlcLimitSats < amountSats) {
             Logger.warn("Insufficient outbound capacity: $totalNextOutboundHtlcLimitSats < $amountSats")
@@ -669,16 +668,6 @@ class LightningService @Inject constructor(
 
 // region helpers
 
-/** Returns only `open` channels, filtering out pending ones. */
-fun List<ChannelDetails>.filterOpen(): List<ChannelDetails> {
-    return this.filter { it.isChannelReady }
-}
-
-/** Returns only `pending` channels. */
-fun List<ChannelDetails>.filterPending(): List<ChannelDetails> {
-    return this.filterNot { it.isChannelReady }
-}
-
 private fun generateLogFilePath(): String {
     val dateFormatter = SimpleDateFormat(DatePattern.LOG_FILE, Locale.US).apply {
         timeZone = TimeZone.getTimeZone("UTC")

app/src/main/java/to/bitkit/services/LnUrlWithdrawService.kt → app/src/main/java/to/bitkit/services/LnurlService.kt

@@ -11,12 +11,13 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 @Singleton
-class LnUrlWithdrawService @Inject constructor(
+class LnurlService @Inject constructor(
     private val client: HttpClient,
 ) {
 
-    suspend fun fetchWithdrawInfo(lnUrlCallBack: String): Result<LnUrlWithdrawResponse> = runCatching {
-        val response: HttpResponse = client.get(lnUrlCallBack)
+    suspend fun fetchWithdrawInfo(callbackUrl: String): Result<LnUrlWithdrawResponse> = runCatching {
+        val response: HttpResponse = client.get(callbackUrl)
+        Logger.debug("Http call: $response")
 
         if (!response.status.isSuccess()) {
             throw Exception("HTTP error: ${response.status}")
@@ -34,9 +35,28 @@ class LnUrlWithdrawService @Inject constructor(
         Logger.warn(e = it, msg = "Failed to fetch withdraw info", context = TAG)
     }
 
+    suspend fun fetchLnurlInvoice(
+        callbackUrl: String,
+        amountSats: ULong,
+        comment: String? = null,
+    ): LnurlPayResponse {
+        val response = client.get(callbackUrl) {
+            url {
+                parameters.append("amount", "${amountSats * 1000u}") // convert to msat
+                comment?.takeIf { it.isNotBlank() }?.let { parameters.append("comment", it) }
+            }
+        }
+        Logger.debug("Http call: $response")
+
+        if (!response.status.isSuccess()) {
+            throw Exception("HTTP error: ${response.status}")
+        }
+
+        return response.body<LnurlPayResponse>()
+    }
 
     companion object {
-        private const val TAG = "LnUrlWithdrawService"
+        private const val TAG = "LnurlService"
     }
 }
 
@@ -52,3 +72,9 @@ data class LnUrlWithdrawResponse(
     val maxWithdrawable: Long? = null,
     val balanceCheck: String? = null
 )
+
+@Serializable
+data class LnurlPayResponse(
+    val pr: String,
+    val routes: List<String>,
+)

app/src/main/java/to/bitkit/ui/ContentView.kt

@@ -335,8 +335,9 @@ fun ContentView(
                                 walletViewModel = walletViewModel,
                                 startDestination = sheet.route,
                                 onComplete = { txSheet ->
-                                    appViewModel.setSendEvent(SendEvent.Reset)
+                                    appViewModel.resetSendState()
                                     appViewModel.hideSheet()
+                                    appViewModel.clearClipboardForAutoRead()
                                     txSheet?.let { appViewModel.showNewTransactionSheet(it) }
                                 }
                             )

app/src/main/java/to/bitkit/ui/components/BalanceHeaderView.kt

@@ -23,6 +23,7 @@ import to.bitkit.R
 import to.bitkit.models.BITCOIN_SYMBOL
 import to.bitkit.models.ConvertedAmount
 import to.bitkit.models.PrimaryDisplay
+import to.bitkit.models.formatToModernDisplay
 import to.bitkit.ui.LocalCurrencies
 import to.bitkit.ui.currencyViewModel
 import to.bitkit.ui.settingsViewModel
@@ -50,7 +51,7 @@ fun BalanceHeaderView(
             smallRowSymbol = "$",
             smallRowText = "12.34",
             largeRowPrefix = prefix,
-            largeRowText = "$sats",
+            largeRowText = sats.formatToModernDisplay(),
             largeRowSymbol = BITCOIN_SYMBOL,
             showSymbol = showBitcoinSymbol,
             hideBalance = false,