feat: add profile and contacts fetching from pubky

CHANGELOG.md

@@ -17,6 +17,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
+- 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
 - Support entry in drawer menu #857

app/build.gradle.kts

@@ -47,6 +47,7 @@ val bcp47Locales = listOf(
     "en", "ar", "es-419", "ca", "cs", "de", "el", "es", "es-ES", "fr", "it", "nl", "pl", "pt", "pt-BR", "ru"
 )
 val e2eBackendEnv = System.getenv("E2E_BACKEND") ?: "local"
+val e2eHomegateUrlEnv = System.getenv("E2E_HOMEGATE_URL") ?: "http://127.0.0.1:6288"
 
 android {
     namespace = "to.bitkit"
@@ -63,6 +64,7 @@ android {
         }
         buildConfigField("boolean", "E2E", System.getenv("E2E")?.toBoolean()?.toString() ?: "false")
         buildConfigField("String", "E2E_BACKEND", "\"$e2eBackendEnv\"")
+        buildConfigField("String", "E2E_HOMEGATE_URL", "\"$e2eHomegateUrlEnv\"")
         buildConfigField("boolean", "GEO", System.getenv("GEO")?.toBoolean()?.toString() ?: "true")
         buildConfigField("String", "LOCALES", "\"${bcp47Locales.joinToString(",")}\"")
     }
@@ -237,6 +239,7 @@ dependencies {
     implementation(libs.bouncycastle.provider.jdk)
     implementation(libs.ldk.node.android) { exclude(group = "net.java.dev.jna", module = "jna") }
     implementation(libs.bitkit.core)
+    implementation(libs.paykit)
     implementation(libs.vss.client)
     // Firebase
     implementation(platform(libs.firebase.bom))
@@ -267,6 +270,9 @@ dependencies {
     implementation(libs.charts)
     implementation(libs.haze)
     implementation(libs.haze.materials)
+    // Image Loading
+    implementation(platform(libs.coil.bom))
+    implementation(libs.coil.compose)
     // Compose Navigation
     implementation(libs.navigation.compose)
     androidTestImplementation(libs.navigation.testing)

app/src/main/AndroidManifest.xml

@@ -3,9 +3,14 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <queries>
+        <package android:name="to.pubky.ring" />
         <intent>
             <action android:name="android.settings.APPLICATION_DETAILS_SETTINGS" />
         </intent>
+        <intent>
+            <action android:name="android.intent.action.VIEW" />
+            <data android:scheme="pubkyauth" />
+        </intent>
     </queries>
 
     <uses-feature
@@ -100,6 +105,7 @@
                 <data android:scheme="lnurlw" />
                 <data android:scheme="lnurlc" />
                 <data android:scheme="lnurlp" />
+                <data android:scheme="pubkyauth" />
             </intent-filter>
 
             <!-- NFC -->

app/src/main/java/to/bitkit/App.kt

@@ -7,6 +7,8 @@ import android.app.Application.ActivityLifecycleCallbacks
 import android.os.Bundle
 import androidx.hilt.work.HiltWorkerFactory
 import androidx.work.Configuration
+import coil3.ImageLoader
+import coil3.SingletonImageLoader
 import dagger.hilt.android.HiltAndroidApp
 import to.bitkit.env.Env
 import javax.inject.Inject
@@ -16,13 +18,17 @@ internal open class App : Application(), Configuration.Provider {
     @Inject
     lateinit var workerFactory: HiltWorkerFactory
 
+    @Inject
+    lateinit var imageLoader: ImageLoader
+
     override val workManagerConfiguration
         get() = Configuration.Builder()
             .setWorkerFactory(workerFactory)
             .build()
 
     override fun onCreate() {
         super.onCreate()
+        SingletonImageLoader.setSafe { imageLoader }
         currentActivity = CurrentActivity().also { registerActivityLifecycleCallbacks(it) }
         Env.initAppStoragePath(filesDir.absolutePath)
     }

app/src/main/java/to/bitkit/data/PubkyImageFetcher.kt

@@ -0,0 +1,50 @@
+package to.bitkit.data
+
+import coil3.ImageLoader
+import coil3.Uri
+import coil3.decode.DataSource
+import coil3.decode.ImageSource
+import coil3.fetch.FetchResult
+import coil3.fetch.Fetcher
+import coil3.fetch.SourceFetchResult
+import coil3.request.Options
+import okio.Buffer
+import org.json.JSONObject
+import to.bitkit.services.PubkyService
+import to.bitkit.utils.Logger
+
+private const val TAG = "PubkyImageFetcher"
+private const val PUBKY_SCHEME = "pubky://"
+
+class PubkyImageFetcher(
+    private val uri: String,
+    private val options: Options,
+    private val pubkyService: PubkyService,
+) : Fetcher {
+
+    override suspend fun fetch(): FetchResult {
+        val data = pubkyService.fetchFile(uri)
+        val blobData = resolveImageData(data)
+        val source = ImageSource(Buffer().apply { write(blobData) }, options.fileSystem)
+        return SourceFetchResult(source, null, dataSource = DataSource.NETWORK)
+    }
+
+    private suspend fun resolveImageData(data: ByteArray): ByteArray = runCatching {
+        val json = JSONObject(String(data))
+        val src = json.optString("src", "")
+        if (src.isNotEmpty() && src.startsWith(PUBKY_SCHEME)) {
+            Logger.debug("Found file descriptor, fetching blob from '$src'", context = TAG)
+            pubkyService.fetchFile(src)
+        } else {
+            data
+        }
+    }.getOrDefault(data)
+
+    class Factory(private val pubkyService: PubkyService) : Fetcher.Factory<Uri> {
+        override fun create(data: Uri, options: Options, imageLoader: ImageLoader): Fetcher? {
+            val uri = data.toString()
+            if (!uri.startsWith(PUBKY_SCHEME)) return null
+            return PubkyImageFetcher(uri, options, pubkyService)
+        }
+    }
+}

app/src/main/java/to/bitkit/data/PubkyStore.kt

@@ -0,0 +1,39 @@
+package to.bitkit.data
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.dataStore
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.serialization.Serializable
+import to.bitkit.data.serializers.PubkyStoreSerializer
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private val Context.pubkyDataStore: DataStore<PubkyStoreData> by dataStore(
+    fileName = "pubky.json",
+    serializer = PubkyStoreSerializer,
+)
+
+@Singleton
+class PubkyStore @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    private val store = context.pubkyDataStore
+
+    val data: Flow<PubkyStoreData> = store.data
+
+    suspend fun update(transform: (PubkyStoreData) -> PubkyStoreData) {
+        store.updateData(transform)
+    }
+
+    suspend fun reset() {
+        store.updateData { PubkyStoreData() }
+    }
+}
+
+@Serializable
+data class PubkyStoreData(
+    val cachedName: String? = null,
+    val cachedImageUri: String? = null,
+)

app/src/main/java/to/bitkit/data/SettingsStore.kt

@@ -99,6 +99,7 @@ data class SettingsData(
     val hasSeenSavingsIntro: Boolean = false,
     val hasSeenShopIntro: Boolean = false,
     val hasSeenProfileIntro: Boolean = false,
+    val hasSeenContactsIntro: Boolean = false,
     val quickPayIntroSeen: Boolean = false,
     val bgPaymentsIntroSeen: Boolean = false,
     val isQuickPayEnabled: Boolean = false,

app/src/main/java/to/bitkit/data/keychain/Keychain.kt

@@ -127,6 +127,8 @@ class Keychain @Inject constructor(
         BIP39_PASSPHRASE,
         PIN,
         PIN_ATTEMPTS_REMAINING,
+        PAYKIT_SESSION,
+        PUBKY_SECRET_KEY,
     }
 }
 

app/src/main/java/to/bitkit/data/serializers/PubkyStoreSerializer.kt

@@ -0,0 +1,27 @@
+package to.bitkit.data.serializers
+
+import androidx.datastore.core.Serializer
+import to.bitkit.data.PubkyStoreData
+import to.bitkit.di.json
+import to.bitkit.utils.Logger
+import java.io.InputStream
+import java.io.OutputStream
+
+object PubkyStoreSerializer : Serializer<PubkyStoreData> {
+    private const val TAG = "PubkyStoreSerializer"
+
+    override val defaultValue: PubkyStoreData = PubkyStoreData()
+
+    override suspend fun readFrom(input: InputStream): PubkyStoreData {
+        return runCatching {
+            json.decodeFromString<PubkyStoreData>(input.readBytes().decodeToString())
+        }.getOrElse {
+            Logger.error("Failed to deserialize PubkyStoreData", it, context = TAG)
+            defaultValue
+        }
+    }
+
+    override suspend fun writeTo(t: PubkyStoreData, output: OutputStream) {
+        output.write(json.encodeToString(t).encodeToByteArray())
+    }
+}

app/src/main/java/to/bitkit/di/ImageModule.kt

@@ -0,0 +1,41 @@
+package to.bitkit.di
+
+import android.content.Context
+import coil3.ImageLoader
+import coil3.disk.DiskCache
+import coil3.disk.directory
+import coil3.memory.MemoryCache
+import coil3.request.crossfade
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import to.bitkit.data.PubkyImageFetcher
+import to.bitkit.services.PubkyService
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object ImageModule {
+
+    @Provides
+    @Singleton
+    fun provideImageLoader(
+        @ApplicationContext context: Context,
+        pubkyService: PubkyService,
+    ): ImageLoader = ImageLoader.Builder(context)
+        .crossfade(true)
+        .components { add(PubkyImageFetcher.Factory(pubkyService)) }
+        .memoryCache {
+            MemoryCache.Builder()
+                .maxSizePercent(context, percent = 0.15)
+                .build()
+        }
+        .diskCache {
+            DiskCache.Builder()
+                .directory(context.cacheDir.resolve("pubky-images"))
+                .build()
+        }
+        .build()
+}

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

@@ -20,6 +20,8 @@ internal object Env {
     const val isE2eTest = BuildConfig.E2E
     const val isGeoblockingEnabled = BuildConfig.GEO
     val e2eBackend = BuildConfig.E2E_BACKEND.lowercase()
+    val isLocalE2eBackend = isE2eTest && e2eBackend == "local"
+    const val e2eHomegateUrl = BuildConfig.E2E_HOMEGATE_URL
     val network = Network.valueOf(BuildConfig.NETWORK)
     val locales = BuildConfig.LOCALES.split(",")
     const val walletSyncIntervalSecs = 10_uL
@@ -53,10 +55,11 @@ internal object Env {
 
     val electrumServerUrl: String
         get() {
-            val isE2eLocal = isE2eTest && e2eBackend == "local"
             return when (network) {
                 Network.BITCOIN -> ElectrumServers.MAINNET.ESPLORA
-                Network.REGTEST -> if (isE2eLocal) ElectrumServers.REGTEST.LOCAL else ElectrumServers.REGTEST.STAG
+                Network.REGTEST -> {
+                    if (isLocalE2eBackend) ElectrumServers.REGTEST.LOCAL else ElectrumServers.REGTEST.STAG
+                }
                 Network.TESTNET -> ElectrumServers.TESTNET
                 else -> TODO("${network.name} network not implemented")
             }
@@ -154,6 +157,42 @@ internal object Env {
     const val BITREFILL_APP = "Bitkit"
     const val BITREFILL_REF = "AL6dyZYt"
 
+    private val pubkyDomain: String
+        get() = when (network) {
+            Network.BITCOIN -> "bitkit.to"
+            else -> "staging.bitkit.to"
+        }
+
+    val pubkyCapabilities: String
+        get() {
+            val prefix = when (network) {
+                Network.BITCOIN -> ""
+                else -> "staging."
+            }
+            return "/pub/$pubkyDomain/:rw,/pub/${prefix}pubky.app/:r,/pub/${prefix}paykit/v0/:rw"
+        }
+
+    val homegateUrl: String
+        get() {
+            if (isLocalE2eBackend) {
+                return e2eHomegateUrl
+            }
+
+            return when (network) {
+                Network.BITCOIN -> "https://homegate.pubky.app"
+                else -> "https://homegate.staging.pubky.app"
+            }
+        }
+
+    val profilePath: String
+        get() = "/pub/$pubkyDomain/profile.json"
+
+    val contactsBasePath: String
+        get() = "/pub/$pubkyDomain/contacts/"
+
+    val blobsBasePath: String
+        get() = "/pub/$pubkyDomain/blobs/"
+
     val rnBackupServerHost: String
         get() = when (network) {
             Network.BITCOIN -> "https://blocktank.synonym.to/backups-ldk"

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

@@ -0,0 +1,44 @@
+package to.bitkit.models
+
+import androidx.compose.runtime.Immutable
+
+@Immutable
+data class PubkyAuthPermission(
+    val path: String,
+    val accessLevel: String,
+) {
+    val displayAccess: String
+        get() = accessLevel.map { char ->
+            when (char) {
+                'r' -> "READ"
+                'w' -> "WRITE"
+                else -> ""
+            }
+        }.filter { it.isNotEmpty() }.joinToString(", ")
+}
+
+data class PubkyAuthRequest(
+    val rawUrl: String,
+    val relay: String,
+    val permissions: List<PubkyAuthPermission>,
+    val serviceNames: List<String>,
+) {
+    companion object {
+        fun parseCapabilities(caps: String): List<PubkyAuthPermission> =
+            caps.split(",")
+                .filter { it.isNotBlank() }
+                .mapNotNull { segment ->
+                    val lastColon = segment.lastIndexOf(':')
+                    if (lastColon <= 0) return@mapNotNull null
+                    val path = segment.substring(0, lastColon)
+                    val access = segment.substring(lastColon + 1)
+                    PubkyAuthPermission(path = path, accessLevel = access)
+                }
+
+        fun extractServiceName(path: String): String? {
+            val parts = path.trimStart('/').split("/")
+            val pubIndex = parts.indexOf("pub")
+            return if (pubIndex >= 0 && pubIndex + 1 < parts.size) parts[pubIndex + 1] else null
+        }
+    }
+}