@breeztech/breez-sdk-spark-react-native 0.21.0 → 0.21.1

package/android/build.gradle

@@ -67,6 +67,7 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    consumerProguardFiles 'proguard-rules.pro'
 
     buildFeatures {
       prefab true
@@ -109,6 +110,7 @@ android {
 
   sourceSets {
     main {
+      main.kotlin.srcDirs += 'src/main/kotlin'
       if (isNewArchitectureEnabled()) {
           java.srcDirs += [
             "generated/java",
@@ -132,6 +134,9 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "androidx.credentials:credentials:1.3.0"
+  implementation "androidx.credentials:credentials-play-services-auth:1.3.0"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/java/com/breeztech/breezsdkspark/BreezSdkSparkReactNativePackage.kt

@@ -10,10 +10,10 @@ import java.util.HashMap
 
 class BreezSdkSparkReactNativePackage : TurboReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == BreezSdkSparkReactNativeModule.NAME) {
-      BreezSdkSparkReactNativeModule(reactContext)
-    } else {
-      null
+    return when (name) {
+      BreezSdkSparkReactNativeModule.NAME -> BreezSdkSparkReactNativeModule(reactContext)
+      BreezSdkSparkPasskeyModule.NAME -> BreezSdkSparkPasskeyModule(reactContext)
+      else -> null
     }
   }
 
@@ -28,6 +28,14 @@ class BreezSdkSparkReactNativePackage : TurboReactPackage() {
         false,  // isCxxModule
         true // isTurboModule
       )
+      moduleInfos[BreezSdkSparkPasskeyModule.NAME] = ReactModuleInfo(
+        BreezSdkSparkPasskeyModule.NAME,
+        BreezSdkSparkPasskeyModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        false // isTurboModule (standard native module)
+      )
       moduleInfos
     }
   }

package/android/src/main/kotlin/com/breeztech/breezsdkspark/BreezSdkSparkPasskeyModule.kt

@@ -0,0 +1,306 @@
+package com.breeztech.breezsdkspark
+
+import android.util.Base64
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import technology.breez.spark.passkey.core.CredentialManagerPrfCore
+import technology.breez.spark.passkey.core.CredentialManagerPrfCoreException
+import technology.breez.spark.passkey.core.PostCreateGraceTracker
+
+/**
+ * React Native native module for passkey PRF operations on Android.
+ *
+ * Thin React-bridge wrapper around [CredentialManagerPrfCore]. All of the
+ * WebAuthn JSON, Credential Manager, and PRF-extraction plumbing lives in
+ * the core helper; this file only translates React Native arguments and
+ * maps [CredentialManagerPrfCoreException] into Promise rejection codes
+ * understood by the JS side.
+ *
+ * Do not hand-edit [CredentialManagerPrfCore.kt] here: it is a generated
+ * mirror of the canonical copy under
+ * `crates/breez-sdk/bindings/langs/shared/android-passkey/`. Run
+ * `cargo xtask sync-passkey-core` after editing the canonical file.
+ */
+@ReactModule(name = BreezSdkSparkPasskeyModule.NAME)
+class BreezSdkSparkPasskeyModule(
+    private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+
+    /**
+     * Module-scoped coroutine scope. Cancelled in [onCatalystInstanceDestroy]
+     * so any in-flight passkey ceremony does not outlive the React context
+     * and leak the captured Activity. SupervisorJob keeps siblings alive if
+     * one branch fails, matching the per-call try/catch pattern below.
+     */
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    /**
+     * Shared across each per-call [CredentialManagerPrfCore] instance so the
+     * post-create grace armed by one ceremony is consumed by the next.
+     * Without sharing, every fresh-per-call core would have its own empty
+     * tracker and the cross-call grace would never fire.
+     */
+    private val graceTracker = PostCreateGraceTracker()
+
+    override fun getName(): String = NAME
+
+    override fun onCatalystInstanceDestroy() {
+        scope.cancel()
+        super.onCatalystInstanceDestroy()
+    }
+
+    /**
+     * Derive multiple 32-byte PRF seeds in a single ceremony when supported
+     * (dual-salt assertion). Falls back to per-salt single-salt assertion
+     * if the authenticator drops the second salt. The `salts.size == 1`
+     * case short-circuits to a single-salt assertion (one prompt).
+     *
+     * @param promise Resolves with a list of base64-encoded 32-byte PRF outputs.
+     */
+    @ReactMethod
+    fun deriveSeeds(
+        saltsArg: com.facebook.react.bridge.ReadableArray,
+        rpId: String,
+        rpName: String,
+        userName: String,
+        userDisplayName: String,
+        autoRegister: Boolean,
+        allowCredentialsArg: com.facebook.react.bridge.ReadableArray,
+        preferImmediatelyAvailableCredentials: Boolean?,
+        promise: Promise,
+    ) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("ERR_NO_ACTIVITY", "No current activity available")
+            return
+        }
+
+        val salts = mutableListOf<String>()
+        for (i in 0 until saltsArg.size()) {
+            val s = saltsArg.getString(i)
+            if (s == null) {
+                promise.reject("ERR_PASSKEY", "Invalid salt at index $i")
+                return
+            }
+            salts.add(s)
+        }
+
+        val allowIds = mutableListOf<ByteArray>()
+        for (i in 0 until allowCredentialsArg.size()) {
+            val b64 = allowCredentialsArg.getString(i) ?: continue
+            allowIds.add(Base64.decode(b64, Base64.NO_WRAP))
+        }
+
+        scope.launch {
+            try {
+                val derivation = CredentialManagerPrfCore(
+                    rpId = rpId,
+                    rpName = rpName,
+                    userName = userName,
+                    userDisplayName = userDisplayName,
+                    activityProvider = { activity },
+                    graceTracker = graceTracker,
+                ).deriveSeeds(
+                    salts = salts,
+                    autoRegister = autoRegister,
+                    allowCredentials = allowIds,
+                    preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials ?: true,
+                )
+                // Encode each seed as base64 so the React bridge can carry
+                // them as an array of strings, plus the asserted credential
+                // ID. JS side base64-decodes back to Uint8Array.
+                val seedsArr = Arguments.createArray()
+                for (seed in derivation.seeds) {
+                    seedsArr.pushString(Base64.encodeToString(seed, Base64.NO_WRAP))
+                }
+                val result = Arguments.createMap()
+                result.putArray("seeds", seedsArr)
+                val credentialId = derivation.credentialId
+                if (credentialId != null) {
+                    result.putString("credentialId", Base64.encodeToString(credentialId, Base64.NO_WRAP))
+                } else {
+                    result.putNull("credentialId")
+                }
+                promise.resolve(result)
+            } catch (e: CredentialManagerPrfCoreException) {
+                promise.reject(e.errorCode, e.message ?: e.defaultMessage)
+            } catch (e: Exception) {
+                promise.reject("ERR_PASSKEY", e.message ?: e.toString())
+            }
+        }
+    }
+
+    /**
+     * Domain association check. Mirrors Flutter Android: degrades
+     * `NotAssociated` results from the public Digital Asset Links API
+     * to `Skipped`, since CredentialManager runs its own check
+     * internally with a fresher GMS-cached statement set.
+     */
+    @ReactMethod
+    fun checkDomainAssociation(rpId: String, promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("ERR_NO_ACTIVITY", "No current activity available")
+            return
+        }
+        scope.launch {
+            try {
+                // Branding fields are unused by the domain check; pass
+                // rpId as a placeholder since this is a check-only core.
+                val outcome = CredentialManagerPrfCore(
+                    rpId = rpId,
+                    rpName = rpId,
+                    userName = rpId,
+                    userDisplayName = rpId,
+                    activityProvider = { activity },
+                ).checkDomainAssociation()
+                val map = Arguments.createMap()
+                when (outcome) {
+                    is technology.breez.spark.passkey.core.DomainAssociationResult.Associated -> {
+                        map.putString("kind", "Associated")
+                    }
+                    is technology.breez.spark.passkey.core.DomainAssociationResult.NotAssociated -> {
+                        map.putString("kind", "Skipped")
+                        map.putString("reason", "[soft-fail on Android] ${outcome.reason}")
+                    }
+                    is technology.breez.spark.passkey.core.DomainAssociationResult.Skipped -> {
+                        map.putString("kind", "Skipped")
+                        map.putString("reason", outcome.reason)
+                    }
+                }
+                promise.resolve(map)
+            } catch (e: Exception) {
+                val map = Arguments.createMap()
+                map.putString("kind", "Skipped")
+                map.putString("reason", "Domain association probe failed: ${e.message ?: e.toString()}")
+                promise.resolve(map)
+            }
+        }
+    }
+
+    /**
+     * Create a new passkey with PRF support.
+     *
+     * Only registers the credential, no seed derivation. Triggers exactly
+     * one platform prompt. Use for multi-step onboarding flows.
+     */
+    @ReactMethod
+    fun createPasskey(
+        rpId: String,
+        rpName: String,
+        userName: String,
+        userDisplayName: String,
+        excludeCredentialsBase64: com.facebook.react.bridge.ReadableArray,
+        registerSaltsArg: com.facebook.react.bridge.ReadableArray,
+        promise: Promise,
+    ) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("ERR_NO_ACTIVITY", "No current activity available")
+            return
+        }
+
+        val excludeIds = mutableListOf<ByteArray>()
+        for (i in 0 until excludeCredentialsBase64.size()) {
+            val b64 = excludeCredentialsBase64.getString(i)
+            excludeIds.add(Base64.decode(b64, Base64.NO_WRAP))
+        }
+
+        val registerSalts = mutableListOf<String>()
+        for (i in 0 until registerSaltsArg.size()) {
+            registerSaltsArg.getString(i)?.let { registerSalts.add(it) }
+        }
+
+        scope.launch {
+            try {
+                val registration = CredentialManagerPrfCore(
+                    rpId = rpId,
+                    rpName = rpName,
+                    userName = userName,
+                    userDisplayName = userDisplayName,
+                    activityProvider = { activity },
+                    graceTracker = graceTracker,
+                ).register(excludeIds, registerSalts)
+                val credential = registration.credential
+                // The core's `register` arms the shared grace tracker so the
+                // next `deriveSeeds` call holds out the credential's
+                // PRF-readiness window without the wrapper having to, and
+                // skips arming it when seeds came back inline.
+                val map = Arguments.createMap()
+                map.putString("credentialId", Base64.encodeToString(credential.credentialId, Base64.NO_WRAP))
+                map.putString("userId", Base64.encodeToString(credential.userId, Base64.NO_WRAP))
+                if (credential.aaguid != null) {
+                    map.putString("aaguid", Base64.encodeToString(credential.aaguid, Base64.NO_WRAP))
+                } else {
+                    map.putNull("aaguid")
+                }
+                if (credential.backupEligible != null) {
+                    map.putBoolean("backupEligible", credential.backupEligible!!)
+                } else {
+                    map.putNull("backupEligible")
+                }
+                // Null unless the authenticator evaluated PRF during the
+                // create ceremony and returned one output per salt. The JS
+                // side then skips the assertion entirely.
+                val seeds = registration.seeds
+                if (seeds != null) {
+                    val seedsArr = Arguments.createArray()
+                    for (seed in seeds) {
+                        seedsArr.pushString(Base64.encodeToString(seed, Base64.NO_WRAP))
+                    }
+                    map.putArray("seeds", seedsArr)
+                } else {
+                    map.putNull("seeds")
+                }
+                promise.resolve(map)
+            } catch (e: CredentialManagerPrfCoreException) {
+                promise.reject(e.errorCode, e.message ?: e.defaultMessage)
+            } catch (e: Exception) {
+                promise.reject("ERR_PASSKEY", e.message ?: e.toString())
+            }
+        }
+    }
+
+    /** Check if PRF-capable passkeys are available on this device. */
+    @ReactMethod
+    fun isSupported(promise: Promise) {
+        promise.resolve(CredentialManagerPrfCore.isSupported())
+    }
+
+    private val CredentialManagerPrfCoreException.errorCode: String
+        get() = when (kind) {
+            CredentialManagerPrfCore.Kind.UserCancelled -> "ERR_USER_CANCELLED"
+            CredentialManagerPrfCore.Kind.UserTimedOut -> "ERR_USER_TIMED_OUT"
+            CredentialManagerPrfCore.Kind.CredentialNotFound -> "ERR_NO_CREDENTIAL"
+            CredentialManagerPrfCore.Kind.PrfNotSupported -> "ERR_PRF_NOT_SUPPORTED"
+            CredentialManagerPrfCore.Kind.Configuration -> "ERR_CONFIGURATION"
+            CredentialManagerPrfCore.Kind.CredentialAlreadyExists -> "ERR_CREDENTIAL_ALREADY_EXISTS"
+            else -> "ERR_PASSKEY"
+        }
+
+    private val CredentialManagerPrfCoreException.defaultMessage: String
+        get() = when (kind) {
+            CredentialManagerPrfCore.Kind.UserCancelled -> "User cancelled the passkey operation"
+            CredentialManagerPrfCore.Kind.UserTimedOut -> "Authenticator timed out"
+            CredentialManagerPrfCore.Kind.CredentialNotFound -> "No passkey credential found for this domain"
+            CredentialManagerPrfCore.Kind.PrfNotSupported -> "PRF not supported by authenticator"
+            CredentialManagerPrfCore.Kind.AuthenticationFailed -> "Passkey authentication failed"
+            CredentialManagerPrfCore.Kind.PrfEvaluationFailed -> "PRF evaluation failed"
+            CredentialManagerPrfCore.Kind.Configuration -> "Platform or app configuration error"
+            CredentialManagerPrfCore.Kind.CredentialAlreadyExists -> "A passkey for this app already exists on this device"
+            CredentialManagerPrfCore.Kind.Generic -> "Passkey operation failed"
+        }
+
+    companion object {
+        const val NAME = "BreezSdkSparkPasskey"
+    }
+}