feat(desktop): Compose Desktop client for the wallet and linking

.github/workflows/shared-core-tests.yml

@@ -10,6 +10,7 @@ on:
       - 'kmp/shared-core/**'
       - 'libs/codes/kikcode/**'
       - 'libs/currency-math/**'
+      - 'libs/device-link/**'
       - 'libs/encryption/**'
       - 'libs/reporting/**'
       - 'libs/analytics-events/**'
@@ -72,6 +73,7 @@ jobs:
             :libs:analytics-events:iosSimulatorArm64Test \
             :libs:codes:kikcode:iosSimulatorArm64Test \
             :libs:currency-math:discrete-curve:iosSimulatorArm64Test \
+            :libs:device-link:iosSimulatorArm64Test \
             :libs:encryption:base58:iosSimulatorArm64Test \
             :libs:encryption:chat-cipher:iosSimulatorArm64Test \
             :libs:encryption:ed25519:iosSimulatorArm64Test \

apps/desktop/build.gradle.kts

@@ -0,0 +1,92 @@
+import org.jetbrains.compose.desktop.application.dsl.TargetFormat
+
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.jetbrains.compose)
+    alias(libs.plugins.metro)
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+metro {
+    interop {
+        includeJavax()
+        includeDagger()
+        enableDaggerRuntimeInterop.set(true)
+    }
+}
+
+dependencies {
+    implementation(compose.desktop.currentOs)
+    implementation(libs.jetbrains.compose.material3)
+    implementation(project(":services:opencode"))
+    implementation(project(":apps:flipcash:features:balance"))
+    implementation(project(":apps:flipcash:core"))
+    implementation(project(":apps:flipcash:shared:transaction-history"))
+    implementation(project(":apps:flipcash:shared:tokens"))
+    implementation(project(":apps:flipcash:shared:funding"))
+    implementation(project(":apps:flipcash:shared:userflags"))
+    implementation(project(":apps:flipcash:shared:analytics"))
+    implementation(project(":apps:flipcash:shared:persistence:sources"))
+    implementation(project(":apps:flipcash:shared:persistence:db"))
+    implementation(project(":services:flipcash"))
+    implementation(project(":libs:coroutines"))
+    implementation(project(":libs:logging"))
+    implementation(project(":ui:resources"))
+    implementation(project(":ui:theme"))
+    implementation(project(":apps:flipcash:shared:theme"))
+    implementation(project(":services:opencode-compose"))
+    implementation(project(":libs:locale:public"))
+    implementation(project(":libs:network:connectivity:public"))
+    implementation(project(":libs:encryption:chat-cipher"))
+    implementation(project(":apps:flipcash:shared:device-link"))
+    implementation(libs.kotlinx.coroutines.swing)
+    implementation(libs.dagger)
+    implementation(libs.grpc.okhttp)
+    implementation(libs.coil3)
+    implementation(libs.coil3.network)
+    implementation(libs.event.bus)
+
+    testImplementation(project(":apps:flipcash:startup-contract"))
+    testImplementation(libs.kotlin.test.junit)
+    testImplementation(libs.kotlinx.coroutines.test)
+}
+
+tasks.withType<Test>().configureEach {
+    // No backend in tests: keep the exchange's rate stream from starting when the graph builds it.
+    systemProperty("opencode.processLifecycle.autoStart", "false")
+}
+
+// Dev-only sign-in phrase (see DesktopSession), forwarded only when local.properties has one. It goes in
+// the environment, not a -D flag, so it stays out of the process's command line.
+val devMnemonic = tryReadProperty(rootProject.rootDir, "flipcash.test.mnemonic", "")
+    .takeIf { it.isNotBlank() }
+
+compose.desktop {
+    application {
+        mainClass = "com.flipcash.desktop.MainKt"
+        nativeDistributions {
+            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
+            packageName = "Flipcash"
+            packageVersion = "1.0.0"
+        }
+    }
+}
+
+tasks.register<JavaExec>("snapshot") {
+    group = "application"
+    description = "Renders the wallet (or, with -Pscreen=link, the link screen) off-screen to a PNG (-Pout=<file>)."
+    classpath = sourceSets["main"].runtimeClasspath
+    mainClass.set("com.flipcash.desktop.SnapshotMainKt")
+    args(
+        providers.gradleProperty("out").getOrElse(layout.buildDirectory.file("wallet.png").get().asFile.path),
+        providers.gradleProperty("screen").getOrElse("wallet"),
+    )
+}
+
+tasks.withType<JavaExec>().configureEach {
+    devMnemonic?.let { environment("FLIPCASH_DEV_MNEMONIC", it) }
+}

apps/desktop/src/main/kotlin/com/flipcash/desktop/DesktopApp.kt

@@ -0,0 +1,68 @@
+package com.flipcash.desktop
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import com.flipcash.app.devicelink.DesktopLinkHost
+import com.flipcash.app.devicelink.ui.DesktopLinkScreen
+import com.flipcash.app.theme.FlipcashTheme
+import com.getcode.theme.CodeTheme
+import java.net.Inet4Address
+import java.net.NetworkInterface
+
+/** The wallet when signed in; otherwise the link screen, which stores the phone's seed and signs in. */
+@Composable
+fun DesktopApp(graph: DesktopGraph, signedIn: Boolean) {
+    var linked by remember { mutableStateOf(signedIn) }
+    if (linked) {
+        DesktopWalletContent(graph)
+    } else {
+        DesktopLinkContent(graph, onSignedIn = { linked = true })
+    }
+}
+
+@Composable
+fun DesktopLinkContent(graph: DesktopGraph, onSignedIn: () -> Unit) {
+    var attempt by remember { mutableIntStateOf(0) }
+    var state by remember { mutableStateOf<DesktopLinkHost.State?>(null) }
+    LaunchedEffect(attempt) {
+        val host = lanAddress()
+        if (host == null) {
+            state = DesktopLinkHost.State.Failed("This computer isn't on a local network")
+            return@LaunchedEffect
+        }
+        DesktopLinkHost(host).link().collect { next ->
+            state = next
+            if (next is DesktopLinkHost.State.Linked) {
+                graph.seedVault.write(next.entropyB64)
+                graph.signIn(next.entropyB64)
+                    .onSuccess { onSignedIn() }
+                    .onFailure { state = DesktopLinkHost.State.Failed("Linked, but sign-in failed: ${it.message}") }
+            }
+        }
+    }
+    FlipcashTheme {
+        Box(Modifier.fillMaxSize().background(CodeTheme.colors.background)) {
+            DesktopLinkScreen(state, onRetry = { attempt++ })
+        }
+    }
+}
+
+/**
+ * The address the phone dials: the first site-local IPv4 address on an interface that is up. The
+ * one piece of linking that stays in the desktop app, since the phone never needs its own address.
+ */
+internal fun lanAddress(): String? = NetworkInterface.getNetworkInterfaces().asSequence()
+    .filter { it.isUp && !it.isLoopback && !it.isVirtual }
+    .flatMap { it.inetAddresses.asSequence() }
+    .filterIsInstance<Inet4Address>()
+    .firstOrNull { it.isSiteLocalAddress }
+    ?.hostAddress

apps/desktop/src/main/kotlin/com/flipcash/desktop/DesktopGraph.kt

@@ -0,0 +1,52 @@
+package com.flipcash.desktop
+
+import com.flipcash.app.analytics.FlipcashAnalytics
+import com.flipcash.app.balance.internal.WalletViewModel
+import com.flipcash.app.tokens.ui.SelectTokenViewModel
+import com.getcode.opencode.exchange.Exchange
+import com.getcode.util.resources.ResourceHelper
+import com.getcode.utils.network.NetworkConnectivityListener
+import com.flipcash.desktop.inject.FlipcashDesktopChannelModule
+import com.flipcash.services.inject.FlipcashModule
+import com.flipcash.desktop.inject.OpenCodeDesktopChannelModule
+import com.getcode.opencode.inject.OpenCodeModule
+import com.getcode.opencode.inject.SessionListenerModule
+import com.getcode.opencode.inject.TransactorModule
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.DependencyGraph
+import javax.inject.Singleton
+
+@Singleton
+@DependencyGraph(
+    scope = AppScope::class,
+    bindingContainers = [
+        OpenCodeModule::class,
+        OpenCodeDesktopChannelModule::class,
+        SessionListenerModule::class,
+        TransactorModule::class,
+        FlipcashModule::class,
+        com.flipcash.services.inject.ChatCryptoModule::class,
+        FlipcashDesktopChannelModule::class,
+        DesktopModule::class,
+    ],
+)
+interface DesktopGraph {
+    val walletViewModel: WalletViewModel
+    val selectTokenViewModel: SelectTokenViewModel
+    val exchange: Exchange
+    val resources: ResourceHelper
+    val networkObserver: NetworkConnectivityListener
+    val analytics: FlipcashAnalytics
+    val userManager: com.flipcash.services.user.UserManager
+    val accountController: com.flipcash.services.controllers.AccountController
+    val seedVault: com.flipcash.app.devicelink.SeedVault
+
+    // Android constructs this eagerly in FlipcashApp.onCreate; it is what turns Events.OnLoggedIn into
+    // SessionListener.onUserLoggedIn calls.
+    val eventRepository: com.getcode.opencode.repositories.EventRepository
+
+    // For DesktopWiringTest: the listener set, and singletons to check are shared across injection sites.
+    val sessionListeners: Set<com.getcode.opencode.providers.SessionListener>
+    val tokenCoordinator: com.flipcash.app.tokens.TokenCoordinator
+    val eventBus: com.hoc081098.channeleventbus.ChannelEventBus
+}

apps/desktop/src/main/kotlin/com/flipcash/desktop/DesktopImageLoader.kt

@@ -0,0 +1,32 @@
+package com.flipcash.desktop
+
+import coil3.ImageLoader
+import coil3.PlatformContext
+import coil3.SingletonImageLoader
+import coil3.disk.DiskCache
+import coil3.network.okhttp.OkHttpNetworkFetcherFactory
+import coil3.request.CachePolicy
+import coil3.request.crossfade
+import okio.Path.Companion.toOkioPath
+
+/**
+ * Desktop counterpart of `FlipcashApp.newImageLoader`. Coil 3 has no network fetcher unless one is
+ * added, so without this every token logo (an https URL) fails with "Unable to create a fetcher".
+ * The chat photo keyer/fetcher are left out: chat is not on desktop.
+ */
+internal fun installImageLoader() {
+    SingletonImageLoader.setSafe { context -> newImageLoader(context) }
+}
+
+private fun newImageLoader(context: PlatformContext): ImageLoader =
+    ImageLoader.Builder(context)
+        .crossfade(true)
+        .memoryCachePolicy(CachePolicy.ENABLED)
+        .diskCache {
+            DiskCache.Builder()
+                .directory(DesktopModule.appDir.resolve("image_cache").toOkioPath())
+                .maxSizeBytes(50L * 1024 * 1024)
+                .build()
+        }
+        .components { add(OkHttpNetworkFetcherFactory()) }
+        .build()

apps/desktop/src/main/kotlin/com/flipcash/desktop/DesktopModule.kt

@@ -0,0 +1,118 @@
+package com.flipcash.desktop
+
+import com.flipcash.app.analytics.FlipcashAnalytics
+import com.flipcash.app.core.AppRoute
+import com.flipcash.app.core.storage.DirectoryPreferencesFiles
+import com.flipcash.app.core.storage.PreferencesFiles
+import com.flipcash.app.devicelink.KeyringSeedVault
+import com.flipcash.app.devicelink.SeedVault
+import com.flipcash.app.funding.PurchaseMethod
+import com.flipcash.app.funding.PurchaseMethodController
+import com.flipcash.app.funding.PurchaseMethodMetadata
+import com.flipcash.app.funding.PurchaseMethodSelection
+import com.flipcash.app.funding.PurchaseMethodState
+import com.flipcash.app.tokens.TokenCoordinator
+import com.flipcash.app.userflags.UserFlagsFiles
+import com.flipcash.libs.coroutines.DispatcherProvider
+import com.getcode.chatcipher.ChatCipher
+import com.getcode.chatcipher.DefaultChatCipher
+import com.getcode.opencode.providers.SessionListener
+import com.getcode.opencode.providers.TokenMetadataProvider
+import com.getcode.util.locale.LocaleHelper
+import com.getcode.util.resources.ComposeResourceHelper
+import com.getcode.util.resources.ResourceHelper
+import com.getcode.utils.network.NetworkConnectivityListener
+import com.getcode.utils.network.NetworkObserverStub
+import dagger.Module
+import dagger.Provides
+import dagger.multibindings.IntoSet
+import java.io.File
+import java.util.Currency
+import java.util.Locale
+import javax.inject.Singleton
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.emptyFlow
+
+/**
+ * Desktop implementations of the seams Android binds in its Hilt modules. Funding, analytics and
+ * connectivity are stubs for this slice; the rest are real.
+ */
+@Module
+object DesktopModule {
+    /** Per-user data directory: the database, DataStore files and no-backup files. */
+    internal val appDir: File by lazy {
+        File(System.getProperty("user.home"), ".flipcash").apply { mkdirs() }
+    }
+
+    @Provides
+    @Singleton
+    fun seedVault(): SeedVault = KeyringSeedVault()
+
+    @Provides
+    @Singleton
+    fun dispatchers(): DispatcherProvider = object : DispatcherProvider {
+        override val Default: CoroutineDispatcher = Dispatchers.Default
+        override val Main: CoroutineDispatcher = Dispatchers.Main
+        override val IO: CoroutineDispatcher = Dispatchers.IO
+    }
+
+    // ChatCryptoModule provides this from its companion object, which Metro's Dagger interop
+    // does not read from a precompiled module.
+    @Provides
+    fun chatCipher(): ChatCipher = DefaultChatCipher
+
+    @Provides
+    fun analytics(): FlipcashAnalytics = FlipcashAnalytics.None
+
+    @Provides
+    @Singleton
+    fun locale(): LocaleHelper = object : LocaleHelper {
+        override fun getLanguageTag(): String = Locale.getDefault().toLanguageTag()
+        override fun getDefaultCurrencyName(): String =
+            runCatching { Currency.getInstance(Locale.getDefault()).currencyCode }.getOrDefault("USD")
+        override suspend fun getDefaultCountry(): String? =
+            Locale.getDefault().country.takeIf { it.length == 2 }
+    }
+
+    @Provides
+    @Singleton
+    fun network(): NetworkConnectivityListener = NetworkObserverStub()
+
+    @Provides
+    @Singleton
+    fun preferencesFiles(): PreferencesFiles = DirectoryPreferencesFiles(appDir)
+
+    @Provides
+    @Singleton
+    fun userFlagsFiles(): UserFlagsFiles = object : UserFlagsFiles {
+        override val noBackupDir: File = File(appDir, "no_backup").apply { mkdirs() }
+        override fun dataStoreFile(name: String): File = File(appDir, "datastore/$name.preferences_pb")
+    }
+
+    @Provides
+    @Singleton
+    fun resources(): ResourceHelper = ComposeResourceHelper()
+
+    @Provides
+    fun tokenMetadata(coordinator: TokenCoordinator): TokenMetadataProvider = coordinator
+
+    // Android adds TokenCoordinator to the listener set in TokenModule, which is Android-only. Without this
+    // the coordinator never sees onUserLoggedIn and the wallet stays on its loading state.
+    @Provides
+    @IntoSet
+    fun tokenSessionListener(coordinator: TokenCoordinator): SessionListener = coordinator
+
+    @Provides
+    @Singleton
+    fun purchaseMethods(): PurchaseMethodController = object : PurchaseMethodController {
+        override val state: StateFlow<PurchaseMethodState> = MutableStateFlow(PurchaseMethodState())
+        override val selections: Flow<PurchaseMethodSelection> = emptyFlow()
+        override fun present(metadata: PurchaseMethodMetadata) = Unit
+        override fun select(method: PurchaseMethod, metadata: PurchaseMethodMetadata) = Unit
+        override suspend fun presentDepositOptions(popToRoot: Boolean): AppRoute? = null
+    }
+}