ovitrif · Oct 26, 2026 · Oct 26, 2026 · Oct 26, 2026 · Oct 26, 2026 · Oct 26, 2026
diff --git a/.github/workflows/release-internal.yml b/.github/workflows/release-internal.yml
@@ -73,6 +73,8 @@ jobs:
           KEYSTORE_PASSWORD: ${{ secrets.INTERNAL_KEYSTORE_PASSWORD }}
           KEY_ALIAS: ${{ secrets.INTERNAL_KEY_ALIAS }}
           KEY_PASSWORD: ${{ secrets.INTERNAL_KEY_PASSWORD }}
+          # Optional: without it the build passes and Spark (Lightning without channels) stays off.
+          BREEZ_API_KEY: ${{ secrets.BREEZ_API_KEY }}
         run: |
           set -euo pipefail
           ./gradlew assembleMainnetRelease --no-daemon --stacktrace

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -66,6 +66,15 @@ jobs:
           printf '%s' "$BITKIT_KEYSTORE_BASE64" | base64 --decode > "$keystore_path"
           echo "KEYSTORE_FILE=$keystore_path" >> "$GITHUB_ENV"
 
+      - name: Check Breez API key
+        env:
+          BREEZ_API_KEY: ${{ secrets.BREEZ_API_KEY }}
+        run: |
+          if [ -z "${BREEZ_API_KEY// /}" ]; then
+            echo "::error::BREEZ_API_KEY is missing from the release environment; a release without it ships with Spark (Lightning without channels) off."
+            exit 1
+          fi
+
       - name: Build release artifacts
         env:
           GPR_USER: ${{ secrets.GPR_USER || github.actor }}
@@ -74,6 +83,7 @@ jobs:
           KEYSTORE_PASSWORD: ${{ secrets.BITKIT_KEYSTORE_PASSWORD }}
           KEY_ALIAS: ${{ secrets.BITKIT_KEY_ALIAS }}
           KEY_PASSWORD: ${{ secrets.BITKIT_KEY_PASSWORD }}
+          BREEZ_API_KEY: ${{ secrets.BREEZ_API_KEY }}
         run: |
           set -euo pipefail
           ./gradlew assembleMainnetRelease bundleMainnetRelease --no-daemon --stacktrace

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -357,6 +357,8 @@ androidComponents {
             "USDT_RPC_URL",
             localProp("USDT_RPC_URL").orElse("https://bitkit.to/v1/usdt/chain-rpc").stringField(),
         )
+        buildConfigFields.put("BREEZ_API_KEY", localProp("BREEZ_API_KEY").orElse("").stringField())
+        buildConfigFields.put("ESPLORA_URL", localProp("ESPLORA_URL").orElse("").stringField())
         buildConfigFields.put("E2E", e2eEnv.booleanField())
         buildConfigFields.put("E2E_BACKEND", e2eBackendEnv.stringField())
         buildConfigFields.put("E2E_LOCAL_HOST", e2eLocalHostEnv.stringField())
@@ -564,6 +566,7 @@ dependencies {
         implementation(libs.bitkit.core)
     }
     implementation(libs.paykit)
+    implementation(libs.breez.sdk.spark) { exclude(group = "net.java.dev.jna", module = "jna") }
     implementation(libs.vss.client)
     if (localBitkitCoreAar == null) nativeDebugSymbols(libs.bitkit.core.nativeDebugSymbolsArtifact())
     nativeDebugSymbols(libs.ldk.node.android.nativeDebugSymbolsArtifact())

diff --git a/app/src/androidTest/java/to/bitkit/ui/screens/transfer/FundingScreenTest.kt b/app/src/androidTest/java/to/bitkit/ui/screens/transfer/FundingScreenTest.kt
@@ -120,6 +120,20 @@ class FundingScreenTest {
         assertEquals(0, manualClicks)
     }
 
+    @Test
+    fun whenGeoBlocked_onlyManualSetupShouldInvoke() {
+        setContent(isGeoBlocked = true)
+
+        clickableTransferOption().performClick()
+        composeTestRule.onNodeWithTag("FundReceive").performClick()
+        composeTestRule.onNodeWithTag("FundManual").performClick()
+        composeTestRule.waitForIdle()
+
+        assertEquals(0, transferClicks)
+        assertEquals(0, fundClicks)
+        assertEquals(1, manualClicks)
+    }
+
     @Test
     fun whenFundableBalanceIsZero_transferShouldNotRouteToTheTransferFlow() {
         setContent(fundableBalance = 0uL)

diff --git a/app/src/main/java/to/bitkit/androidServices/LightningNodeService.kt b/app/src/main/java/to/bitkit/androidServices/LightningNodeService.kt
@@ -12,6 +12,7 @@ import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationCompat
 import androidx.core.app.ServiceCompat
 import androidx.core.content.ContextCompat
+import com.synonym.bitkitcore.usdtFormatAmount
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.launch
@@ -32,8 +33,12 @@ import to.bitkit.domain.commands.NotifyPendingPaymentResolved
 import to.bitkit.domain.commands.NotifyPendingPaymentResolvedHandler
 import to.bitkit.ext.activityManager
 import to.bitkit.models.NewTransactionSheetDetails
+import to.bitkit.models.NewTransactionSheetDirection
+import to.bitkit.models.NewTransactionSheetType
 import to.bitkit.models.NotificationDetails
 import to.bitkit.repositories.LightningRepo
+import to.bitkit.repositories.SparkRepo
+import to.bitkit.repositories.SparkUsdTransfer
 import to.bitkit.repositories.WalletRepo
 import to.bitkit.services.NodeEventHandler
 import to.bitkit.services.NodeServiceFgState
@@ -79,6 +84,9 @@ class LightningNodeService : Service() {
     @Inject
     lateinit var nodeServiceFgState: NodeServiceFgState
 
+    @Inject
+    lateinit var sparkRepo: SparkRepo
+
     private var hasStartedNode = false
 
     private val nodeEventHandler: NodeEventHandler = { event ->
@@ -91,6 +99,7 @@ class LightningNodeService : Service() {
     private fun setupService() {
         if (hasStartedNode) return
         hasStartedNode = true
+        serviceScope.launch { sparkRepo.usdReceived.collect { notifySparkUsdReceived(it) } }
 
         serviceScope.launch {
             lightningRepo.start(
@@ -144,6 +153,18 @@ class LightningNodeService : Service() {
         pushNotification(notification.title, notification.body)
     }
 
+    private suspend fun notifySparkUsdReceived(transfer: SparkUsdTransfer) {
+        if (App.currentActivity?.value != null) return
+        val sheet = NewTransactionSheetDetails(
+            type = NewTransactionSheetType.LIGHTNING,
+            direction = NewTransactionSheetDirection.RECEIVED,
+            usdtAmount = transfer.amount,
+            sparkUsdTransferId = transfer.id,
+        )
+        cacheStore.setBackgroundReceive(sheet)
+        pushNotification(getString(R.string.usdt__received_title_spark), "$ " + usdtFormatAmount(transfer.amount))
+    }
+
     private suspend fun handlePendingPaymentResolved(event: Event) {
         val command = NotifyPendingPaymentResolved.Command.from(event) ?: return
 

diff --git a/app/src/main/java/to/bitkit/domain/commands/ReceivedNotificationContent.kt b/app/src/main/java/to/bitkit/domain/commands/ReceivedNotificationContent.kt
@@ -16,8 +16,7 @@ import javax.inject.Singleton
 
 /**
  * Builds the user-facing "Payment Received" notification content, applying the same currency
- * formatting rules everywhere a received payment is surfaced (foreground service, in-app handler,
- * and the background [to.bitkit.fcm.WakeNodeWorker] push path).
+ * formatting rules everywhere a received payment is surfaced (foreground service and in-app handler).
  */
 @Singleton
 class ReceivedNotificationContent @Inject constructor(

diff --git a/app/src/main/java/to/bitkit/env/Env.kt b/app/src/main/java/to/bitkit/env/Env.kt
@@ -4,13 +4,9 @@ import android.os.Build
 import com.synonym.bitkitcore.UsdtDestination
 import org.lightningdevkit.ldknode.LogLevel
 import org.lightningdevkit.ldknode.Network
-import org.lightningdevkit.ldknode.PeerDetails
 import to.bitkit.BuildConfig
 import to.bitkit.BuildConfig.VERSION_NAME
 import to.bitkit.ext.ensureDir
-import to.bitkit.ext.of
-import to.bitkit.models.BlocktankNotificationType
-import to.bitkit.models.NodePeer
 import to.bitkit.utils.Logger
 import java.io.File
 import kotlin.io.path.Path
@@ -35,6 +31,29 @@ internal object Env {
         ).filter { it.first in enabled }.map { it.second }
     }
 
+    val breezApiKey: String? get() = BuildConfig.BREEZ_API_KEY.takeIf { it.isNotBlank() }
+
+    /**
+     * The Spark token held as the dollar balance on Spark, matched by identifier since anyone can issue a token
+     * with any ticker. Mainnet holds USDB, Brale's 6-decimal dollar token on Spark; regtest holds a 6-decimal
+     * "Test USDB" token issued on Lightspark's regtest.
+     */
+    /** Orchestra, which bridges Spark dollars to Arbitrum USDT, serves mainnet only. */
+    val isSparkBridgeAvailable: Boolean get() = network == Network.BITCOIN
+
+    val sparkUsdTokenId: String?
+        get() = when (network) {
+            Network.REGTEST -> "btknrt1wrr0qtshpyuzrx5p0mvd605dnwvfv3dcpfexqgfzpgl3rykdacsq6p8z6l"
+            Network.BITCOIN -> "btkn1xgrvjwey5ngcagvap2dzzvsy4uk8ua9x69k82dwvt5e7ef9drm9qztux87"
+            else -> null
+        }
+
+    /**
+     * Esplora endpoint for the node's chain source on regtest builds, set to put the wallet on Spark's regtest chain
+     * through `scripts/spark-regtest-esplora.py`; Electrum is used when unset.
+     */
+    val regtestEsploraUrl: String?
+        get() = BuildConfig.ESPLORA_URL.takeIf { it.isNotBlank() && network == Network.REGTEST }
     val isDebug = BuildConfig.DEBUG
     const val isE2eTest = BuildConfig.E2E
     const val isGeoblockingEnabled = BuildConfig.GEO
@@ -52,14 +71,6 @@ internal object Env {
 
     val ldkLogLevel = LogLevel.TRACE
 
-    val trustedLnPeers
-        get() = when (network) {
-            Network.BITCOIN -> listOf(Peers.lnd1, Peers.lnd3, Peers.lnd4)
-            Network.REGTEST -> listOf(Peers.stag)
-            Network.TESTNET -> listOf(Peers.stag)
-            else -> listOf()
-        }
-
     /**
      * Whether LN -> onchain swaps can reach a Boltz backend. Boltz only serves a public API on
      * mainnet: its testnet deployment is deprecated and regtest resolves to a local backend that
@@ -71,9 +82,6 @@ internal object Env {
     const val fxRateStaleThreshold = 10 * 60 * 1000L // 10 minutes in millis
     const val lspOrdersRefreshInterval = 2 * 60 * 1000L // 2 minutes in millis
 
-    val pushNotificationFeatures = BlocktankNotificationType.entries
-    const val derivationName = "bitkit-notifications"
-
     const val FILE_PROVIDER_AUTHORITY = "${BuildConfig.APPLICATION_ID}.fileprovider"
     const val SUPPORT_EMAIL = "support@synonym.to"
     const val PIN_LENGTH = 4
@@ -140,11 +148,6 @@ internal object Env {
             Network.BITCOIN -> "$blocktankBaseUrl/api"
             else -> "$blocktankBaseUrl/blocktank/api/v2"
         }
-    val blocktankNotificationApiUrl
-        get() = when (network) {
-            Network.BITCOIN -> "$blocktankBaseUrl/api/notifications"
-            else -> "$blocktankBaseUrl/notifications/api"
-        }
 
     val btcRatesServer
         get() = when (network) {
@@ -177,6 +180,7 @@ internal object Env {
     const val BITKIT_TELEGRAM = "https://t.me/bitkitchat"
     const val BITKIT_GITHUB = "https://github.com/synonymdev"
     const val BITKIT_HELP_CENTER = "https://help.bitkit.to"
+    const val BLOCKTANK_SUNSET_URL = "https://blog.bitkit.to/"
     const val TERMS_OF_USE_URL = "https://bitkit.to/terms-of-use"
     const val PRIVACY_POLICY_URL = "https://bitkit.to/privacy-policy"
     const val STORING_BITCOINS_URL = "https://en.bitcoin.it/wiki/Storing_bitcoins"
@@ -238,6 +242,12 @@ internal object Env {
 
     fun ldkStoragePath(walletIndex: Int) = storagePathOf(walletIndex, network.name.lowercase(), "ldk")
 
+    fun sparkStoragePath(walletIndex: Int) = storagePathOf(walletIndex, network.name.lowercase(), "spark")
+
+    /** A restored Spark exit data backup waiting to be imported once Spark connects; outside Spark's storage. */
+    fun sparkExitRestorePath(walletIndex: Int) =
+        Path(storagePathOf(walletIndex, network.name.lowercase(), "spark-restore"), "exit-state.json").toString()
+
     fun bitkitCoreStoragePath(walletIndex: Int): String {
         return storagePathOf(walletIndex, network.name.lowercase(), "core")
     }
@@ -283,28 +293,6 @@ object Defaults {
     const val TAG_MAX_LENGTH = 20
 }
 
-object Peers {
-    val stag = PeerDetails.of("028a8910b0048630d4eb17af25668cdd7ea6f2d8ae20956e7a06e2ae46ebcb69fc@34.65.86.104:9400")
-    val lnd1 = PeerDetails.of("039b8b4dd1d88c2c5db374290cda397a8f5d79f312d6ea5d5bfdfc7c6ff363eae3@34.65.111.104:9735")
-    val lnd3 = PeerDetails.of("03816141f1dce7782ec32b66a300783b1d436b19777e7c686ed00115bd4b88ff4b@34.65.191.64:9735")
-    val lnd4 = PeerDetails.of("02a371038863605300d0b3fc9de0cf5ccb57728b7f8906535709a831b16e311187@34.65.153.174:9735")
-
-    object Known {
-        val stag = NodePeer(Peers.stag, name = "Synonym-Own-Regtest-0")
-        val lnd1 = NodePeer(Peers.lnd1, name = "Blocktank-LND1")
-        val lnd3 = NodePeer(Peers.lnd3, name = "Blocktank-LND3")
-        val lnd4 = NodePeer(Peers.lnd4, name = "Blocktank-LND4")
-
-        fun find(peer: PeerDetails): NodePeer? = when (peer.nodeId) {
-            stag.peerDetails.nodeId -> stag
-            lnd1.peerDetails.nodeId -> lnd1
-            lnd3.peerDetails.nodeId -> lnd3
-            lnd4.peerDetails.nodeId -> lnd4
-            else -> null
-        }
-    }
-}
-
 private object ElectrumServers {
     object MAINNET {
         const val ESPLORA = "ssl://bitkit.to:9999"

diff --git a/app/src/main/java/to/bitkit/ext/LightningBalance.kt b/app/src/main/java/to/bitkit/ext/LightningBalance.kt
@@ -24,6 +24,17 @@ fun LightningBalance.channelId(): String {
     }
 }
 
+fun LightningBalance.counterpartyNodeId(): String {
+    return when (this) {
+        is LightningBalance.ClaimableOnChannelClose -> this.counterpartyNodeId
+        is LightningBalance.ClaimableAwaitingConfirmations -> this.counterpartyNodeId
+        is LightningBalance.ContentiousClaimable -> this.counterpartyNodeId
+        is LightningBalance.MaybeTimeoutClaimableHtlc -> this.counterpartyNodeId
+        is LightningBalance.MaybePreimageClaimableHtlc -> this.counterpartyNodeId
+        is LightningBalance.CounterpartyRevokedOutputClaimable -> this.counterpartyNodeId
+    }
+}
+
 fun LightningBalance.claimableAtHeight(): UInt? = when (this) {
     is LightningBalance.ClaimableAwaitingConfirmations -> this.confirmationHeight
     is LightningBalance.ContentiousClaimable -> this.timeoutHeight