@authon/react-native-wallet 0.1.0 → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# @authon/react-native-wallet
+
+## 0.4.0
+
+- `signChainTransaction({ chain, account, address, payload })` for app-built transactions on other chains (NATIVE.md section 12): Solana (`{ message }` → `{ signature }`), TRON (`{ rawDataHex }` → `{ txID, signature }`), Bitcoin and Bitcoin testnet (`{ psbt }` → `{ psbt, txHex? }`) and XRP (`{ txBlobHex }` → `{ signature }`). EVM stays on `signTransaction` (`INVALID_PARAMS` for `chain: 'evm'`). The native approval UI summarizes the transaction before the key is assembled.
+- `getAccounts` passes through `publicKey` when the native wallet returns one (XRP).
+
+## 0.3.0
+
+- `getAccounts({ start, count, chain })`: account addresses on `evm` (default), `tron`, `xrp`, `bitcoin`, `bitcoin-testnet` and `solana`, derived from the same seed with the standard paths. Each account carries its `chain`; a native wallet that answers without it is refused (`UNSUPPORTED_TYPE`). Signing stays EVM only.
+
+## 0.2.0
+
+- `capabilities()`: checks before sign-in whether this device and app can use the wallet (app registration and approval, wallet enabled, hardware key storage, device lock, passkey backup support), with reason codes and the app-config `diagnosticId`. No session needed.
+- `AuthonWalletError` has `diagnosticId` (server request ID) and `retryable`, passed through from the Swift and Kotlin wallets.
+- iOS: a second signature right after the first no longer hangs; the approval sheet fails with `CONFIRM_WINDOW_BLOCKED` when it cannot be shown.
+
+## 0.1.0
+
+- First release: Expo module over the Swift and Kotlin embedded wallets (status, create/ensure, accounts, personal_sign, EIP-712, transactions, passkey protect/upgrade/restore, device revoke), `useAuthonWallet()` with `@authon/react-native`.

package/README.md

@@ -4,7 +4,7 @@
 > (`AuthonWallet`) and Kotlin (`dev.authon.sdk.wallet`) wallet implementations.
 
 [![License](https://img.shields.io/badge/license-MIT-blue)](../../LICENSE)
-[![Version](https://img.shields.io/badge/version-0.1.0-blue)]()
+[![Version](https://img.shields.io/badge/version-0.4.0-blue)]()
 
 It is the same wallet as the web SDK (`@authon/js`): same wallet row, same `/v1/wallet/me/*` API,
 same shares. A user gets the same address in your web app and your mobile app, and the app install
@@ -27,8 +27,12 @@ appears as one more device in the wallet's device list.
 - iOS 16+ (iOS 18+ for passkey backup and restore, which need the passkey PRF extension).
 - Android minSdk 28, compileSdk 35+. Passkey backup and restore need Google Play services with a
   passkey provider that supports PRF (Google Password Manager on Android 9+ with current Play services).
-- EVM chains: personal_sign, EIP-712 v4, legacy / EIP-2930 / EIP-1559 transactions, HD accounts
+- Signing: EVM (personal_sign, EIP-712 v4, legacy / EIP-2930 / EIP-1559 transactions), HD accounts
   `m/44'/60'/0'/0/n`.
+- Addresses (receive / display) from the same seed: TRON `m/44'/195'/n'/0/0`, XRP `m/44'/144'/n'/0/0`,
+  Bitcoin P2WPKH `m/84'/0'/n'/0/0` (testnet `m/84'/1'/n'/0/0`), Solana `m/44'/501'/n'/0'`. These
+  chains sign through `signChainTransaction` (the app builds the transaction; fees, balances and broadcast are up to the app). A wallet created before HD wallets has EVM account 0 only
+  (`ACCOUNT_UNAVAILABLE` for other chains).
 
 ## Install
 
@@ -128,14 +132,16 @@ Method names and result shapes follow `@authon/js` (`WalletClient`).
 
 | Method | Description |
 |---|---|
+| `capabilities()` | Pre-sign-in check of this device and app (see below). No session, creates nothing, opens no UI. |
 | `appConfig()` | App registration and wallet settings: `{ projectId, allowed, approved, enabled, chainIds, confirmSigning, rpId, minFrameProtocol }`. No session needed. |
 | `get()` / `status()` | The signed-in user's wallet `{ address, protected, needsRestore, backupUpgradeRecommended, devices }`, or `null` when there is none. |
 | `create()` | Creates the wallet (or returns the existing one). |
 | `ensure()` | `get()`, then `create()` when there is no wallet. Concurrent calls share one request. |
 | `isProtected()` | True when the wallet has a passkey backup. |
-| `getAccounts({ start, count })` | HD account addresses `{ index, path, address }` (public, no approval). |
+| `getAccounts({ start, count, chain })` | HD account addresses `{ index, path, address, chain }` (public, no approval). `chain`: `evm` (default), `tron`, `xrp`, `bitcoin`, `bitcoin-testnet`, `solana`. |
 | `signMessage(message, { account })` | EIP-191 personal_sign; `message` is text or `{ raw: '0x...' }`. |
 | `signTypedData(typedData, { account })` | EIP-712 v4. |
+| `signChainTransaction({ chain, account, address, payload })` | Signs an app-built transaction: Solana `{ message }` (base64 Message) → `{ signature }` (base58); TRON `{ rawDataHex }` → `{ txID, signature }`; Bitcoin / testnet `{ psbt }` (base64, every input with witness_utxo; only our P2WPKH inputs are signed) → `{ psbt, txHex? }` (txHex when every input is ours); XRP `{ txBlobHex }` (encodeForSigning output with SigningPubKey = `getAccounts({ chain: 'xrp' })` `publicKey`) → `{ signature }` (DER). The approval UI summarizes it; unknown programs are shown as high risk. `address` must be the account's address on that chain (`ADDRESS_MISMATCH` otherwise). |
 | `signTransaction(tx, { account })` | Legacy, EIP-2930 or EIP-1559; returns the serialized signed transaction. `bigint` values are allowed. |
 | `protect()` | Creates the passkey backup. Do not let users receive funds before the wallet is protected. |
 | `upgradeBackup()` | Replaces a legacy backup (`backupUpgradeRecommended`) with a verifiable one. |
@@ -159,14 +165,38 @@ Options of `createAuthonWallet` / `useAuthonWallet`:
 | `requireDeviceAuthentication` | Also ask for Face ID / Touch ID / passcode (iOS) or BiometricPrompt (Android) before each signature. |
 | `testing` | **Test only**, refused outside debug builds: `{ allowSoftwareKeys, autoApprove }` for simulators and emulators (software device keys instead of Secure Enclave / StrongBox, and no approval UI). Never ship it. |
 
+### Before sign-in: `capabilities()`
+
+```ts
+const caps = await wallet.capabilities();
+if (caps.ready === 'unavailable') showWalletUnavailable(caps); // tell the user before sign-in
+// 'unknown': continue, but be ready for that feature to fail
+```
+
+`{ ready, app, wallet, secureStorage, deviceLock, passkeyBackup, diagnosticId }`; each check is
+`{ status: 'available' | 'unavailable' | 'unknown', reason }`. `ready` is `unavailable` if any check is,
+else `unknown` if any is, else `available`. It answers for a release build (the `testing` options are
+ignored).
+
+| Check | unavailable reason | unknown reason |
+|---|---|---|
+| `app` | `APP_NOT_REGISTERED`, `APP_SIGNATURE_MISMATCH` (Android: the running app's signing certificate differs from the registered one) | `APP_NOT_APPROVED` (signing works, passkey backup waits for approval), `NETWORK_ERROR`, `API_ERROR` |
+| `wallet` | `WALLET_DISABLED` | `NETWORK_ERROR` |
+| `secureStorage` | `HARDWARE_KEYSTORE_UNAVAILABLE` | `SIMULATOR` (simulators and emulators never count as hardware protected), `CHECK_FAILED` |
+| `deviceLock` | `DEVICE_LOCK_NOT_SET` | `CHECK_FAILED` |
+| `passkeyBackup` | `OS_UNSUPPORTED` (iOS < 18, Android < 9), `PASSKEY_API_UNAVAILABLE` | `PRF_PROVIDER_UNVERIFIED` (the provider's PRF support is confirmed on the first `protect()`) |
+
 ### Errors
 
-Every failure is an `AuthonWalletError` with a `code`. Codes are the web wallet's
+Every failure is an `AuthonWalletError` with `code`, `message`, `diagnosticId` (the server's request ID
+when an API response caused it; log it, never secrets) and `retryable`. Codes are the web wallet's
 (`NOT_FOUND`, `NEEDS_RESTORE`, `NOT_PROTECTED`, `PRF_UNSUPPORTED`, `ORIGIN_NOT_ALLOWED`,
 `USER_CANCELLED`, `UNAUTHORIZED`, `ADDRESS_MISMATCH`, `STORAGE_UNAVAILABLE`, `LAST_DEVICE`,
 `MESSAGE_TOO_LARGE`, `FRAME_OUTDATED`, `BACKUP_KEY_REQUIRED`, `ALREADY_UPGRADED`,
 `ACCOUNT_UNAVAILABLE`, ...), reported unchanged by the Swift and Kotlin wallets. The JS layer adds
 `NOT_SIGNED_IN` (no token), `INVALID_PARAMS`, `DISPOSED` and `NOT_CONFIGURED` (native module missing).
+`USER_CANCELLED` means the user rejected the approval or closed the passkey sheet: go back without an
+error message. `CONFIRM_WINDOW_BLOCKED` means the approval UI could not be shown; nothing was signed.
 
 ```ts
 try {

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
   <uses-permission android:name="android.permission.INTERNET" />
   <uses-permission android:name="android.permission.USE_BIOMETRIC" />
+  <!-- capabilities(): checks whether Google Play services (passkey provider) is installed. -->
+  <queries>
+    <package android:name="com.google.android.gms" />
+  </queries>
 </manifest>

package/android/src/main/java/dev/authon/reactnative/wallet/AuthonWalletModule.kt

@@ -2,6 +2,9 @@ package dev.authon.reactnative.wallet
 
 import android.content.pm.ApplicationInfo
 import dev.authon.sdk.wallet.AuthonWallet
+import dev.authon.sdk.wallet.CapabilityCheck
+import dev.authon.sdk.wallet.WalletCapabilities
+import dev.authon.sdk.wallet.WalletChain
 import dev.authon.sdk.wallet.PublicWallet
 import dev.authon.sdk.wallet.RestoreMode
 import dev.authon.sdk.wallet.SignAccount
@@ -15,6 +18,15 @@ import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import java.util.concurrent.ConcurrentHashMap
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.longOrNull
 import kotlin.coroutines.AbstractCoroutineContextElement
 import kotlin.coroutines.CoroutineContext
 import kotlinx.coroutines.CancellationException
@@ -47,6 +59,10 @@ class AuthonWalletModule : Module() {
       call(id, null) { appConfig(it.appConfig()) }
     }
 
+    AsyncFunction("capabilities") Coroutine { id: String ->
+      call(id, null) { capabilities(it.capabilities()) }
+    }
+
     AsyncFunction("status") Coroutine { id: String, token: String ->
       call(id, token) { wallet(it.status()) }
     }
@@ -55,9 +71,11 @@ class AuthonWalletModule : Module() {
       call(id, token) { wallet(it.create()) }
     }
 
-    AsyncFunction("accounts") Coroutine { id: String, token: String, start: Int, count: Int ->
+    AsyncFunction("accounts") Coroutine { id: String, token: String, start: Int, count: Int, chain: String ->
       call(id, token) { w ->
-        w.accounts(start.toLong(), count).map { mapOf("index" to it.index.toInt(), "path" to it.path, "address" to it.address) }
+        w.accounts(start.toLong(), count, WalletChain.fromWire(chain)).map {
+          mapOf("index" to it.index.toInt(), "path" to it.path, "address" to it.address, "chain" to it.chain.wire, "publicKey" to it.publicKey)
+        }
       }
     }
 
@@ -76,6 +94,10 @@ class AuthonWalletModule : Module() {
       call(id, token) { it.signTransaction(transactionJson, SignAccount.parse(account.toLong(), address)) }
     }
 
+    AsyncFunction("signChainTransaction") Coroutine { id: String, token: String, chain: String, account: Int, address: String, payloadJson: String ->
+      call(id, token) { it.signChainTransaction(WalletChain.fromWire(chain), account.toLong(), address, parsePayload(payloadJson)) }
+    }
+
     AsyncFunction("protect") Coroutine { id: String, token: String ->
       call(id, token) { mapOf("shareVersion" to it.protect().shareVersion) }
     }
@@ -149,7 +171,26 @@ class AuthonWalletModule : Module() {
 
   private fun failure(e: Throwable): Map<String, Any?> {
     val w = e as? WalletException ?: WalletException(WalletErrorCode.INTERNAL, "unexpected error")
-    return mapOf("ok" to false, "code" to w.code.name, "message" to (w.message ?: w.code.name))
+    return mapOf(
+      "ok" to false,
+      "code" to w.code.name,
+      "message" to (w.message ?: w.code.name),
+      "diagnosticId" to w.diagnosticId,
+      "retryable" to w.retryable,
+    )
+  }
+
+  private fun parsePayload(json: String): Map<String, Any?> {
+    val obj = runCatching { Json.parseToJsonElement(json) }.getOrNull() as? JsonObject
+      ?: throw WalletException(WalletErrorCode.INVALID_REQUEST, "payload must be a JSON object")
+    return obj.mapValues { (_, v) -> plain(v) }
+  }
+
+  private fun plain(e: JsonElement): Any? = when (e) {
+    is JsonNull -> null
+    is JsonObject -> e.mapValues { (_, v) -> plain(v) }
+    is JsonArray -> e.map { plain(it) }
+    is JsonPrimitive -> if (e.isString) e.content else e.booleanOrNull ?: e.longOrNull ?: e.doubleOrNull
   }
 
   // Public data only
@@ -164,6 +205,19 @@ class AuthonWalletModule : Module() {
     },
   )
 
+  private fun capabilities(c: WalletCapabilities): Map<String, Any?> {
+    fun check(k: CapabilityCheck) = mapOf("status" to k.status.wire, "reason" to k.reason)
+    return mapOf(
+      "ready" to c.ready.wire,
+      "app" to check(c.app),
+      "wallet" to check(c.wallet),
+      "secureStorage" to check(c.secureStorage),
+      "deviceLock" to check(c.deviceLock),
+      "passkeyBackup" to check(c.passkeyBackup),
+      "diagnosticId" to c.diagnosticId,
+    )
+  }
+
   private fun appConfig(c: WalletAppConfig): Map<String, Any?> = mapOf(
     "projectId" to c.projectId,
     "allowed" to c.allowed,

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/AndroidCapabilityProbe.kt

@@ -0,0 +1,86 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/AndroidCapabilityProbe.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import android.app.KeyguardManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.security.KeyPairGenerator
+import java.security.KeyStore
+import java.security.MessageDigest
+import java.security.spec.ECGenParameterSpec
+import java.util.UUID
+
+/** Device checks for capabilities() on Android. Test-only software-key settings are ignored. */
+class AndroidCapabilityProbe(context: Context) : CapabilityProbe {
+    private val appContext = context.applicationContext
+
+    override fun signingCertSha256(): String? {
+        if (Build.VERSION.SDK_INT < 28) return null
+        val info = appContext.packageManager.getPackageInfo(appContext.packageName, PackageManager.GET_SIGNING_CERTIFICATES)
+        val cert = info.signingInfo?.apkContentsSigners?.firstOrNull() ?: return null
+        return fingerprint(cert.toByteArray())
+    }
+
+    override suspend fun secureStorage(): CapabilityCheck = withContext(Dispatchers.IO) {
+        if (isEmulator()) return@withContext CapabilityCheck.unknown(Capabilities.SIMULATOR)
+        val alias = "dev.authon.wallet.probe.${UUID.randomUUID()}"
+        val ks = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
+        try {
+            val spec = KeyGenParameterSpec.Builder(alias, KeyProperties.PURPOSE_SIGN)
+                .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
+                .setDigests(KeyProperties.DIGEST_SHA256)
+                .build()
+            val pair = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore").apply { initialize(spec) }.generateKeyPair()
+            when (KeystoreSecurity.levelOf(pair.private)) {
+                KeySecurityLevel.STRONGBOX, KeySecurityLevel.TRUSTED_ENVIRONMENT, KeySecurityLevel.UNKNOWN_SECURE -> CapabilityCheck.AVAILABLE
+                KeySecurityLevel.SOFTWARE -> CapabilityCheck.unavailable(Capabilities.HARDWARE_KEYSTORE_UNAVAILABLE)
+                KeySecurityLevel.UNKNOWN -> CapabilityCheck.unknown(Capabilities.CHECK_FAILED)
+            }
+        } catch (_: Exception) {
+            CapabilityCheck.unknown(Capabilities.CHECK_FAILED)
+        } finally {
+            runCatching { ks.deleteEntry(alias) }
+        }
+    }
+
+    override fun deviceLock(): CapabilityCheck {
+        val km = appContext.getSystemService(KeyguardManager::class.java) ?: return CapabilityCheck.unknown(Capabilities.CHECK_FAILED)
+        return if (km.isDeviceSecure) CapabilityCheck.AVAILABLE else CapabilityCheck.unavailable(Capabilities.DEVICE_LOCK_NOT_SET)
+    }
+
+    override fun passkeyBackup(): CapabilityCheck {
+        if (Build.VERSION.SDK_INT < 28) return CapabilityCheck.unavailable(Capabilities.OS_UNSUPPORTED)
+        // Android 14+ ships the Credential Manager framework service; older versions need Play services.
+        val framework = Build.VERSION.SDK_INT >= 34 && appContext.getSystemService("credential") != null
+        val playServices = try {
+            appContext.packageManager.getApplicationInfo("com.google.android.gms", 0).enabled
+        } catch (_: PackageManager.NameNotFoundException) {
+            false
+        }
+        return if (framework || playServices) {
+            CapabilityCheck.unknown(Capabilities.PRF_PROVIDER_UNVERIFIED)
+        } else {
+            CapabilityCheck.unavailable(Capabilities.PASSKEY_API_UNAVAILABLE)
+        }
+    }
+
+    companion object {
+        fun fingerprint(der: ByteArray): String =
+            MessageDigest.getInstance("SHA-256").digest(der).joinToString(":") { "%02X".format(it.toInt() and 0xff) }
+
+        /** Conservative emulator detection (goldfish/ranchu hardware, generic/emulator builds). */
+        fun isEmulator(): Boolean {
+            val hw = Build.HARDWARE.lowercase()
+            val fp = Build.FINGERPRINT.lowercase()
+            val product = Build.PRODUCT.lowercase()
+            return hw.contains("goldfish") || hw.contains("ranchu") || fp.startsWith("generic") ||
+                fp.contains("emulator") || fp.contains("/sdk_gphone") || product.startsWith("sdk_gphone") ||
+                product.contains("emulator") || product.contains("simulator")
+        }
+    }
+}

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/AuthonWallet.kt

@@ -44,6 +44,7 @@ class AuthonWallet internal constructor(
     private val passkeysFactory: (rpId: String) -> PasskeyProvider,
     private val approver: WalletApprover?,
     private val deviceAuthenticator: DeviceAuthenticator?,
+    private val probe: CapabilityProbe?,
     private val dispatcher: CoroutineContext = Dispatchers.Default,
 ) {
     /**
@@ -69,6 +70,7 @@ class AuthonWallet internal constructor(
         passkeysFactory = { rpId -> options.passkeys ?: CredentialManagerPasskeys(activityProvider, rpId) },
         approver = options.approver ?: DialogWalletApprover(activityProvider),
         deviceAuthenticator = if (options.requireDeviceAuthentication) BiometricDeviceAuthenticator(activityProvider) else null,
+        probe = AndroidCapabilityProbe(context),
     )
 
     private val mutex = Mutex()
@@ -77,6 +79,17 @@ class AuthonWallet internal constructor(
     /** This app's wallet configuration from the API (cached after the first success). */
     suspend fun appConfig(): WalletAppConfig = run { config ?: api.appConfig(packageName).also { config = it } }
 
+    /**
+     * Whether this device and app can use the wallet (NATIVE.md section 9). Needs no session,
+     * opens no login or passkey UI, creates nothing, and never throws.
+     */
+    suspend fun capabilities(): WalletCapabilities = withContext(dispatcher) {
+        val p = probe ?: throw IllegalStateException("no capability probe")
+        val (caps, cfg) = Capabilities.evaluate(api, packageName, p)
+        if (cfg != null) config = cfg
+        caps
+    }
+
     private class Ready(val ops: WalletOps, val session: String, val config: WalletAppConfig)
 
     private suspend fun ready(): Ready {
@@ -123,7 +136,9 @@ class AuthonWallet internal constructor(
     /** Creates the wallet (two-phase; resumes or discards an interrupted attempt), or returns the existing one. */
     suspend fun create(): PublicWallet = op { it.ops.toPublicWallet(it.ops.createWallet(it.session)) }
 
-    suspend fun accounts(start: Long = 0, count: Int = 1): List<WalletAccount> = op { it.ops.accounts(it.session, start, count) }
+    /** Addresses of accounts start..start+count-1 on [chain] (NATIVE.md section 11). Signing is EVM only. */
+    suspend fun accounts(start: Long = 0, count: Int = 1, chain: WalletChain = WalletChain.EVM): List<WalletAccount> =
+        op { it.ops.accounts(it.session, start, count, chain) }
 
     suspend fun signMessage(message: String, account: SignAccount = SignAccount.PRIMARY): String =
         signMessage(WalletMessage.Text(message), account)
@@ -150,6 +165,17 @@ class AuthonWallet internal constructor(
     suspend fun signTransaction(transactionJson: String, account: SignAccount = SignAccount.PRIMARY): String =
         op { it.ops.signTransaction(it.session, parseObject(transactionJson), account) }
 
+    /**
+     * Signs an app-built transaction on another chain (NATIVE.md section 12). Solana: payload
+     * `message` (serialized legacy/v0 Message, base64, at most 1232 bytes) and optional `cluster`
+     * (shown as "Solana <cluster>"); returns `signature` (base58). The signer must be the fee payer,
+     * and [address] must be the chain address of [account] (from accounts()). TRON: payload
+     * `rawDataHex` (raw_data protobuf, at most 4096 bytes); returns `txID` and `signature`
+     * (r||s||v hex); the owner must be the signer.
+     */
+    suspend fun signChainTransaction(chain: WalletChain, account: Long, address: String, payload: Map<String, Any?>): Map<String, String> =
+        op { it.ops.signChainTransaction(it.session, chain, account, address, payload) }
+
     /** Creates the passkey backup (B) of an unprotected wallet. */
     suspend fun protect(): ProtectResult = op {
         requirePasskeyApproval(it.config)
@@ -186,6 +212,7 @@ class AuthonWallet internal constructor(
             passkeys: PasskeyProvider,
             approver: WalletApprover?,
             deviceAuthenticator: DeviceAuthenticator? = null,
-        ) = AuthonWallet(api, packageName, sessionProvider, store, { passkeys }, approver, deviceAuthenticator)
+            probe: CapabilityProbe? = null,
+        ) = AuthonWallet(api, packageName, sessionProvider, store, { passkeys }, approver, deviceAuthenticator, probe)
     }
 }