@solana-mobile/mobile-wallet-adapter-protocol 1.0.0 → 1.0.1

package/README.md

@@ -1,63 +1,70 @@
-# `@solana-mobile/mobile-wallet-adapter-protocol`
-
-This is a reference implementation of the [Mobile Wallet Adapter specification](https://github.com/solana-mobile/mobile-wallet-adapter/blob/main/spec/spec.md) in JavaScript. Use this to start a session with a mobile wallet in which you can issue API calls to it (eg. `sign_messages`) as per the spec.
-
-If you are simply looking to integrate a JavaScript application with mobile wallets, see [`@solana-mobile/wallet-adapter-mobile`](https://www.npmjs.com/package/@solana-mobile/wallet-adapter-mobile) instead.
-
-## Quick start
-
-Use this API to start a session:
-
-```typescript
-import {transact} from '@solana-mobile/mobile-wallet-adapter-protocol';
-
-await transact(async (wallet) => {
-    /* ... */
-});
-```
-
-The callback you provide will be called once a session has been established with a wallet. It will recieve the `MobileWallet` API as an argument. You can call protocol-specified methods using this function. Whatever you return from this callback will be returned by `transact`.
-
-```typescript
-const signedPayloads = await transact(async (wallet) => {
-    const {signed_payloads} = await wallet.signMessages({
-        auth_token,
-        payloads: [/* ... */],
-    });
-    return signed_payloads;
-});
-```
-
-The wallet session will stay active until your callback returns. Typically, wallets will redirect back to your app once the session ends.
-
-## Exception handling
-
-You can catch exceptions at any level. See `errors.ts` for a list of exceptions that might be thrown.
-
-```typescript
-try {
-    await transact(async (wallet) => {
-        try {
-            await wallet.signTransactions(/* ... */);
-        } catch (e) {
-            if (
-                e instanceof SolanaMobileWalletAdapterProtocolError &&
-                e.code === SolanaMobileWalletAdapterProtocolErrorCode.ERROR_REAUTHORIZE
-            ) {
-                console.error('The auth token has gone stale');
-                await wallet.reauthorize({auth_token});
-                // Retry...
-            }
-            throw e;
-        }
-    });
-} catch(e) {
-    if (
-        e instanceof SolanaMobileWalletAdapterError &&
-        e.code === SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND
-    ) {
-        /* ... */
-    }
-    throw e;
-}
+# `@solana-mobile/mobile-wallet-adapter-protocol`
+
+This is a reference implementation of the [Mobile Wallet Adapter specification](https://github.com/solana-mobile/mobile-wallet-adapter/blob/main/spec/spec.md) in JavaScript. Use this to start a session with a mobile wallet in which you can issue API calls to it (eg. `sign_messages`) as per the spec.
+
+If you are simply looking to integrate a JavaScript application with mobile wallets, see [`@solana-mobile/wallet-adapter-mobile`](https://www.npmjs.com/package/@solana-mobile/wallet-adapter-mobile) instead.
+
+## Learn how to use this API on our [documentation website](https://docs.solanamobile.com/):
+- React Native
+    - [Quickstart Setup](https://docs.solanamobile.com/react-native/quickstart)
+    - [dApp Integration Guide](https://docs.solanamobile.com/react-native/mwa_integration_rn)
+    - [Hello World Tutorial](https://docs.solanamobile.com/getting-started/hello_world_tutorial)
+- [Sample App Reference](https://docs.solanamobile.com/sample-apps/sample_app_overview)
+
+## Quick start
+
+Use this API to start a session:
+
+```typescript
+import {transact} from '@solana-mobile/mobile-wallet-adapter-protocol';
+
+await transact(async (wallet) => {
+    /* ... */
+});
+```
+
+The callback you provide will be called once a session has been established with a wallet. It will recieve the `MobileWallet` API as an argument. You can call protocol-specified methods using this function. Whatever you return from this callback will be returned by `transact`.
+
+```typescript
+const signedPayloads = await transact(async (wallet) => {
+    const {signed_payloads} = await wallet.signMessages({
+        auth_token,
+        payloads: [/* ... */],
+    });
+    return signed_payloads;
+});
+```
+
+The wallet session will stay active until your callback returns. Typically, wallets will redirect back to your app once the session ends.
+
+## Exception handling
+
+You can catch exceptions at any level. See `errors.ts` for a list of exceptions that might be thrown.
+
+```typescript
+try {
+    await transact(async (wallet) => {
+        try {
+            await wallet.signTransactions(/* ... */);
+        } catch (e) {
+            if (
+                e instanceof SolanaMobileWalletAdapterProtocolError &&
+                e.code === SolanaMobileWalletAdapterProtocolErrorCode.ERROR_REAUTHORIZE
+            ) {
+                console.error('The auth token has gone stale');
+                await wallet.reauthorize({auth_token, identity});
+                // Retry...
+            }
+            throw e;
+        }
+    });
+} catch(e) {
+    if (
+        e instanceof SolanaMobileWalletAdapterError &&
+        e.code === SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND
+    ) {
+        /* ... */
+    }
+    throw e;
+}
 ```

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Wed Mar 08 13:54:55 MST 2023
+gradle.version=7.5

package/android/build.gradle

@@ -1,146 +1,146 @@
-buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['SolanaMobileWalletAdapterModule_kotlinVersion']
-
-  repositories {
-      google()
-      mavenCentral()
-  }
-
-  dependencies {
-    classpath 'com.android.tools.build:gradle:3.5.4'
-    // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-  }
-}
-
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
-}
-
-apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
-
-if (isNewArchitectureEnabled()) {
-  apply plugin: 'com.facebook.react'
-}
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['SolanaMobileWalletAdapterModule_' + name]
-}
-
-def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['SolanaMobileWalletAdapterModule_' + name]).toInteger()
-}
-
-android {
-  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
-
-  defaultConfig {
-    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
-    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-  }
-  buildTypes {
-    release {
-      minifyEnabled false
-    }
-  }
-
-  lintOptions {
-    disable 'GradleCompatible'
-  }
-
-  compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
-  }
-}
-
-repositories {
-  mavenCentral()
-  google()
-
-  def found = false
-  def defaultDir = null
-  def androidSourcesName = 'React Native sources'
-
-  if (rootProject.ext.has('reactNativeAndroidRoot')) {
-    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
-  } else {
-    defaultDir = new File(
-      projectDir,
-      '/../../../node_modules/react-native/android'
-    )
-  }
-
-  if (defaultDir.exists()) {
-    maven {
-      url defaultDir.toString()
-      name androidSourcesName
-    }
-
-    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
-    found = true
-  } else {
-    def parentDir = rootProject.projectDir
-
-    1.upto(5, {
-      if (found) return true
-      parentDir = parentDir.parentFile
-
-      def androidSourcesDir = new File(
-        parentDir,
-        'node_modules/react-native'
-      )
-
-      def androidPrebuiltBinaryDir = new File(
-        parentDir,
-        'node_modules/react-native/android'
-      )
-
-      if (androidPrebuiltBinaryDir.exists()) {
-        maven {
-          url androidPrebuiltBinaryDir.toString()
-          name androidSourcesName
-        }
-
-        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
-        found = true
-      } else if (androidSourcesDir.exists()) {
-        maven {
-          url androidSourcesDir.toString()
-          name androidSourcesName
-        }
-
-        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
-        found = true
-      }
-    })
-  }
-
-  if (!found) {
-    throw new GradleException(
-      "${project.name}: unable to locate React Native android sources. " +
-      "Ensure you have you installed React Native as a dependency in your project and try again."
-    )
-  }
-}
-
-def kotlin_version = getExtOrDefault('kotlinVersion')
-
-dependencies {
-  //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"  // From node_modules
-  implementation "com.solanamobile:mobile-wallet-adapter-clientlib:0.9.0"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.2"
-}
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "SolanaMobileWalletAdapterModule"
-    codegenJavaPackageName = "com.solanamobile.mobilewalletadapter.reactnative"
-  }
-}
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['SolanaMobileWalletAdapterModule_kotlinVersion']
+
+  repositories {
+      google()
+      mavenCentral()
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:7.4.2'
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['SolanaMobileWalletAdapterModule_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['SolanaMobileWalletAdapterModule_' + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+
+  def found = false
+  def defaultDir = null
+  def androidSourcesName = 'React Native sources'
+
+  if (rootProject.ext.has('reactNativeAndroidRoot')) {
+    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
+  } else {
+    defaultDir = new File(
+      projectDir,
+      '/../../../node_modules/react-native/android'
+    )
+  }
+
+  if (defaultDir.exists()) {
+    maven {
+      url defaultDir.toString()
+      name androidSourcesName
+    }
+
+    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
+    found = true
+  } else {
+    def parentDir = rootProject.projectDir
+
+    1.upto(5, {
+      if (found) return true
+      parentDir = parentDir.parentFile
+
+      def androidSourcesDir = new File(
+        parentDir,
+        'node_modules/react-native'
+      )
+
+      def androidPrebuiltBinaryDir = new File(
+        parentDir,
+        'node_modules/react-native/android'
+      )
+
+      if (androidPrebuiltBinaryDir.exists()) {
+        maven {
+          url androidPrebuiltBinaryDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
+        found = true
+      } else if (androidSourcesDir.exists()) {
+        maven {
+          url androidSourcesDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
+        found = true
+      }
+    })
+  }
+
+  if (!found) {
+    throw new GradleException(
+      "${project.name}: unable to locate React Native android sources. " +
+      "Ensure you have you installed React Native as a dependency in your project and try again."
+    )
+  }
+}
+
+def kotlin_version = getExtOrDefault('kotlinVersion')
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"  // From node_modules
+  implementation "com.solanamobile:mobile-wallet-adapter-clientlib:1.1.0"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "SolanaMobileWalletAdapterModule"
+    codegenJavaPackageName = "com.solanamobile.mobilewalletadapter.reactnative"
+  }
+}

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/android/src/main/java/com/solanamobile/mobilewalletadapter/reactnative/SolanaMobileWalletAdapterModule.kt

@@ -1,139 +1,176 @@
-package com.solanamobile.mobilewalletadapter.reactnative
-
-import android.content.ActivityNotFoundException
-import android.net.Uri
-import android.util.Log
-import com.facebook.react.bridge.*
-import com.solana.mobilewalletadapter.clientlib.protocol.JsonRpc20Client
-import com.solana.mobilewalletadapter.clientlib.protocol.MobileWalletAdapterClient
-import com.solana.mobilewalletadapter.clientlib.scenario.LocalAssociationIntentCreator
-import com.solana.mobilewalletadapter.clientlib.scenario.LocalAssociationScenario
-import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertJsonToMap
-import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertMapToJson
-import kotlinx.coroutines.*
-import kotlinx.coroutines.sync.Mutex
-import org.json.JSONObject
-import java.util.concurrent.ExecutionException
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.TimeoutException
-
-class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext), CoroutineScope {
-
-    data class SessionState(
-        val client: MobileWalletAdapterClient,
-        val localAssociation: LocalAssociationScenario,
-    )
-
-    override val coroutineContext =
-        Dispatchers.IO + CoroutineName("SolanaMobileWalletAdapterModuleScope") + SupervisorJob()
-
-    companion object {
-        private const val ASSOCIATION_TIMEOUT_MS = 10000
-        private const val CLIENT_TIMEOUT_MS = 90000
-
-        // Used to ensure that you can't start more than one session at a time.
-        private val mutex: Mutex = Mutex()
-        private var sessionState: SessionState? = null
-    }
-
-    override fun getName(): String {
-        return "SolanaMobileWalletAdapter"
-    }
-
-    @ReactMethod
-    fun startSession(config: ReadableMap?, promise: Promise) = launch {
-        mutex.lock()
-        Log.d(name, "startSession with config $config")
-        try {
-            val uriPrefix = config?.getString("baseUri")?.let { Uri.parse(it) }
-            val localAssociation = LocalAssociationScenario(
-                CLIENT_TIMEOUT_MS,
-            )
-            val intent = LocalAssociationIntentCreator.createAssociationIntent(
-                uriPrefix,
-                localAssociation.port,
-                localAssociation.session
-            )
-            currentActivity?.startActivityForResult(intent, 0)
-                ?: throw NullPointerException("Could not find a current activity from which to launch a local association")
-            val client =
-                localAssociation.start().get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
-            sessionState = SessionState(client, localAssociation)
-            promise.resolve(true)
-        } catch (e: ActivityNotFoundException) {
-            Log.e(name, "Found no installed wallet that supports the mobile wallet protocol", e)
-            cleanup()
-            promise.reject("ERROR_WALLET_NOT_FOUND", e)
-        } catch (e: TimeoutException) {
-            Log.e(name, "Timed out waiting for local association to be ready", e)
-            cleanup()
-            promise.reject("Timed out waiting for local association to be ready", e)
-        } catch (e: InterruptedException) {
-            Log.w(name, "Interrupted while waiting for local association to be ready", e)
-            cleanup()
-            promise.reject(e)
-        } catch (e: ExecutionException) {
-            Log.e(name, "Failed establishing local association with wallet", e.cause)
-            cleanup()
-            promise.reject(e)
-        } catch (e: Throwable) {
-            Log.e(name, "Failed to start session", e)
-            cleanup()
-            promise.reject(e)
-        }
-    }
-
-    @ReactMethod
-    fun invoke(method: String, params: ReadableMap, promise: Promise) = sessionState?.let {
-        Log.d(name, "invoke `$method` with params $params")
-        try {
-            val result = it.client.methodCall(
-                method,
-                convertMapToJson(params),
-                CLIENT_TIMEOUT_MS
-            ).get() as JSONObject
-            promise.resolve(convertJsonToMap(result))
-        } catch (e: ExecutionException) {
-            val cause = e.cause
-            if (cause is JsonRpc20Client.JsonRpc20RemoteException) {
-                val userInfo = Arguments.createMap()
-                userInfo.putInt("jsonRpcErrorCode", cause.code)
-                promise.reject("JSON_RPC_ERROR", cause, userInfo)
-            } else {
-                throw e
-            }
-        } catch (e: Throwable) {
-            Log.e(name, "Failed to invoke `$method` with params $params", e)
-            promise.reject(e)
-        }
-    } ?: throw NullPointerException("Tried to invoke `$method` without an active session")
-
-    @ReactMethod
-    fun endSession(promise: Promise) = sessionState?.let {
-        launch {
-            Log.d(name, "endSession")
-            try {
-                it.localAssociation.close()
-                    .get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
-                cleanup()
-                promise.resolve(true)
-            } catch (e: TimeoutException) {
-                Log.e(name, "Timed out waiting for local association to close", e)
-                cleanup()
-                promise.reject("Failed to end session", e)
-            } catch (e: Throwable) {
-                Log.e(name, "Failed to end session", e)
-                cleanup()
-                promise.reject("Failed to end session", e)
-            }
-        }
-    } ?: throw NullPointerException("Tried to end a session without an active session")
-
-    private fun cleanup() {
-        sessionState = null
-        if (mutex.isLocked) {
-            mutex.unlock()
-        }
-    }
-}
+package com.solanamobile.mobilewalletadapter.reactnative
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.net.Uri
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.solana.mobilewalletadapter.clientlib.protocol.JsonRpc20Client
+import com.solana.mobilewalletadapter.clientlib.protocol.MobileWalletAdapterClient
+import com.solana.mobilewalletadapter.clientlib.scenario.LocalAssociationIntentCreator
+import com.solana.mobilewalletadapter.clientlib.scenario.LocalAssociationScenario
+import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertJsonToMap
+import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertMapToJson
+import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.Mutex
+import org.json.JSONObject
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+
+class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), CoroutineScope {
+
+    data class SessionState(
+        val client: MobileWalletAdapterClient,
+        val localAssociation: LocalAssociationScenario,
+    )
+
+    override val coroutineContext =
+        Dispatchers.IO + CoroutineName("SolanaMobileWalletAdapterModuleScope") + SupervisorJob()
+
+    companion object {
+        private const val ASSOCIATION_TIMEOUT_MS = 10000
+        private const val CLIENT_TIMEOUT_MS = 90000
+        private const val REQUEST_LOCAL_ASSOCIATION = 0
+
+        // Used to ensure that you can't start more than one session at a time.
+        private val mutex: Mutex = Mutex()
+        private var sessionState: SessionState? = null
+    }
+
+    private val mActivityEventCallbacks = mutableMapOf<Int, (Int, Intent?) -> (Unit)>()
+    private val mActivityEventListener: ActivityEventListener =
+        object : BaseActivityEventListener() {
+            override fun onActivityResult(
+                activity: Activity?,
+                requestCode: Int,
+                resultCode: Int,
+                data: Intent?
+            ) {
+                mActivityEventCallbacks[requestCode]?.let { callback ->
+                    callback(resultCode, data)
+                    mActivityEventCallbacks.remove(requestCode)
+                }
+            }
+        }
+
+    init {
+        reactContext.addActivityEventListener(mActivityEventListener)
+    }
+
+    override fun getName(): String {
+        return "SolanaMobileWalletAdapter"
+    }
+
+    @ReactMethod
+    fun startSession(config: ReadableMap?, promise: Promise) = launch {
+        mutex.lock()
+        Log.d(name, "startSession with config $config")
+        try {
+            val uriPrefix = config?.getString("baseUri")?.let { Uri.parse(it) }
+            val localAssociation = LocalAssociationScenario(
+                CLIENT_TIMEOUT_MS,
+            )
+            val intent = LocalAssociationIntentCreator.createAssociationIntent(
+                uriPrefix,
+                localAssociation.port,
+                localAssociation.session
+            )
+            launchIntent(intent, REQUEST_LOCAL_ASSOCIATION) { resultCode, _ ->
+                if (resultCode == Activity.RESULT_CANCELED) {
+                    Log.d(name, "Local association cancelled by user, ending session")
+                    promise.reject("Session not established: Local association cancelled by user", 
+                        LocalAssociationScenario.ConnectionFailedException("Local association cancelled by user"))
+                    localAssociation.close()
+                }
+            }
+            val client =
+                localAssociation.start().get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
+            sessionState = SessionState(client, localAssociation)
+            promise.resolve(true)
+        } catch (e: ActivityNotFoundException) {
+            Log.e(name, "Found no installed wallet that supports the mobile wallet protocol", e)
+            cleanup()
+            promise.reject("ERROR_WALLET_NOT_FOUND", e)
+        } catch (e: TimeoutException) {
+            Log.e(name, "Timed out waiting for local association to be ready", e)
+            cleanup()
+            promise.reject("Timed out waiting for local association to be ready", e)
+        } catch (e: InterruptedException) {
+            Log.w(name, "Interrupted while waiting for local association to be ready", e)
+            cleanup()
+            promise.reject(e)
+        } catch (e: ExecutionException) {
+            Log.e(name, "Failed establishing local association with wallet", e.cause)
+            cleanup()
+            promise.reject(e)
+        } catch (e: Throwable) {
+            Log.e(name, "Failed to start session", e)
+            cleanup()
+            promise.reject(e)
+        }
+    }
+
+    @ReactMethod
+    fun invoke(method: String, params: ReadableMap, promise: Promise) = sessionState?.let {
+        Log.d(name, "invoke `$method` with params $params")
+        try {
+            val result = it.client.methodCall(
+                method,
+                convertMapToJson(params),
+                CLIENT_TIMEOUT_MS
+            ).get() as JSONObject
+            promise.resolve(convertJsonToMap(result))
+        } catch (e: ExecutionException) {
+            val cause = e.cause
+            if (cause is JsonRpc20Client.JsonRpc20RemoteException) {
+                val userInfo = Arguments.createMap()
+                userInfo.putInt("jsonRpcErrorCode", cause.code)
+                promise.reject("JSON_RPC_ERROR", cause, userInfo)
+            } else {
+                throw e
+            }
+        } catch (e: Throwable) {
+            Log.e(name, "Failed to invoke `$method` with params $params", e)
+            promise.reject(e)
+        }
+    } ?: throw NullPointerException("Tried to invoke `$method` without an active session")
+
+    @ReactMethod
+    fun endSession(promise: Promise) = sessionState?.let {
+        launch {
+            Log.d(name, "endSession")
+            try {
+                it.localAssociation.close()
+                    .get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
+                cleanup()
+                promise.resolve(true)
+            } catch (e: TimeoutException) {
+                Log.e(name, "Timed out waiting for local association to close", e)
+                cleanup()
+                promise.reject("Failed to end session", e)
+            } catch (e: Throwable) {
+                Log.e(name, "Failed to end session", e)
+                cleanup()
+                promise.reject("Failed to end session", e)
+            }
+        }
+    } ?: throw NullPointerException("Tried to end a session without an active session")
+
+    private fun launchIntent(intent: Intent, requestCode: Int, callback: (Int, Intent?) -> (Unit)) {
+        mActivityEventCallbacks[requestCode] = callback
+        currentActivity?.startActivityForResult(intent, REQUEST_LOCAL_ASSOCIATION) ?: run {
+            mActivityEventCallbacks.remove(requestCode)
+            throw NullPointerException("Could not find a current activity from which to launch a local association")
+        }
+    }
+
+    private fun cleanup() {
+        sessionState = null
+        if (mutex.isLocked) {
+            mutex.unlock()
+        }
+    }
+}

package/lib/types/index.browser.d.ts

@@ -143,6 +143,7 @@ interface GetCapabilitiesAPI {
 interface ReauthorizeAPI {
     reauthorize(params: {
         auth_token: AuthToken;
+        identity: AppIdentity;
     }): Promise<AuthorizationResult>;
 }
 interface SignMessagesAPI {

package/lib/types/index.d.ts

@@ -143,6 +143,7 @@ interface GetCapabilitiesAPI {
 interface ReauthorizeAPI {
     reauthorize(params: {
         auth_token: AuthToken;
+        identity: AppIdentity;
     }): Promise<AuthorizationResult>;
 }
 interface SignMessagesAPI {

package/lib/types/index.native.d.ts

@@ -143,6 +143,7 @@ interface GetCapabilitiesAPI {
 interface ReauthorizeAPI {
     reauthorize(params: {
         auth_token: AuthToken;
+        identity: AppIdentity;
     }): Promise<AuthorizationResult>;
 }
 interface SignMessagesAPI {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@solana-mobile/mobile-wallet-adapter-protocol",
     "description": "An implementation of the Solana Mobile Mobile Wallet Adapter protocol. Use this to open a session with a mobile wallet app, and to issue API calls to it.",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "author": "Steven Luscher <steven.luscher@solanamobile.com>",
     "repository": "https://github.com/solana-mobile/mobile-wallet-adapter",
     "license": "Apache-2.0",

package/src/types.ts

@@ -1,111 +1,111 @@
-import type { TransactionVersion } from '@solana/web3.js';
-
-export type Account = Readonly<{
-    address: Base64EncodedAddress;
-    label?: string;
-}>;
-
-/**
- * Properties that wallets may present to users when an app
- * asks for authorization to execute privileged methods (see
- * {@link PrivilegedMethods}).
- */
-export type AppIdentity = Readonly<{
-    uri?: string;
-    icon?: string;
-    name?: string;
-}>;
-
-/**
- * An ephemeral elliptic-curve keypair on the P-256 curve.
- * This public key is used to create the association token.
- * The private key is used during session establishment.
- */
-export type AssociationKeypair = CryptoKeyPair;
-
-/**
- * The context returned from a wallet after having authorized a given
- * account for use with a given application. You can cache this and
- * use it later to invoke privileged methods.
- */
-export type AuthorizationResult = Readonly<{
-    accounts: Account[];
-    auth_token: AuthToken;
-    wallet_uri_base: string;
-}>;
-
-export type AuthToken = string;
-
-export type Base64EncodedAddress = string;
-
-type Base64EncodedSignature = string;
-
-type Base64EncodedMessage = string;
-
-type Base64EncodedSignedMessage = string;
-
-type Base64EncodedSignedTransaction = string;
-
-export type Base64EncodedTransaction = string;
-
-export type Cluster = 'devnet' | 'testnet' | 'mainnet-beta';
-
-export type Finality = 'confirmed' | 'finalized' | 'processed';
-
-export type WalletAssociationConfig = Readonly<{
-    baseUri?: string;
-}>;
-
-export interface AuthorizeAPI {
-    authorize(params: { cluster: Cluster; identity: AppIdentity }): Promise<AuthorizationResult>;
-}
-export interface CloneAuthorizationAPI {
-    cloneAuthorization(params: { auth_token: AuthToken }): Promise<Readonly<{ auth_token: AuthToken }>>;
-}
-export interface DeauthorizeAPI {
-    deauthorize(params: { auth_token: AuthToken }): Promise<Readonly<Record<string, never>>>;
-}
-
-export interface GetCapabilitiesAPI {
-    getCapabilities(): Promise<
-        Readonly<{
-            supports_clone_authorization: boolean;
-            supports_sign_and_send_transactions: boolean;
-            max_transactions_per_request: boolean;
-            max_messages_per_request: boolean;
-            supported_transaction_versions: ReadonlyArray<TransactionVersion>;
-        }>
-    >;
-}
-export interface ReauthorizeAPI {
-    reauthorize(params: { auth_token: AuthToken }): Promise<AuthorizationResult>;
-}
-export interface SignMessagesAPI {
-    signMessages(params: {
-        addresses: Base64EncodedAddress[];
-        payloads: Base64EncodedMessage[];
-    }): Promise<Readonly<{ signed_payloads: Base64EncodedSignedMessage[] }>>;
-}
-export interface SignTransactionsAPI {
-    signTransactions(params: {
-        payloads: Base64EncodedTransaction[];
-    }): Promise<Readonly<{ signed_payloads: Base64EncodedSignedTransaction[] }>>;
-}
-export interface SignAndSendTransactionsAPI {
-    signAndSendTransactions(params: {
-        options?: Readonly<{
-            min_context_slot?: number;
-        }>;
-        payloads: Base64EncodedTransaction[];
-    }): Promise<Readonly<{ signatures: Base64EncodedSignature[] }>>;
-}
-
-export interface MobileWallet
-    extends AuthorizeAPI,
-        CloneAuthorizationAPI,
-        DeauthorizeAPI,
-        GetCapabilitiesAPI,
-        ReauthorizeAPI,
-        SignMessagesAPI,
-        SignTransactionsAPI,
-        SignAndSendTransactionsAPI {}
+import type { TransactionVersion } from '@solana/web3.js';
+
+export type Account = Readonly<{
+    address: Base64EncodedAddress;
+    label?: string;
+}>;
+
+/**
+ * Properties that wallets may present to users when an app
+ * asks for authorization to execute privileged methods (see
+ * {@link PrivilegedMethods}).
+ */
+export type AppIdentity = Readonly<{
+    uri?: string;
+    icon?: string;
+    name?: string;
+}>;
+
+/**
+ * An ephemeral elliptic-curve keypair on the P-256 curve.
+ * This public key is used to create the association token.
+ * The private key is used during session establishment.
+ */
+export type AssociationKeypair = CryptoKeyPair;
+
+/**
+ * The context returned from a wallet after having authorized a given
+ * account for use with a given application. You can cache this and
+ * use it later to invoke privileged methods.
+ */
+export type AuthorizationResult = Readonly<{
+    accounts: Account[];
+    auth_token: AuthToken;
+    wallet_uri_base: string;
+}>;
+
+export type AuthToken = string;
+
+export type Base64EncodedAddress = string;
+
+type Base64EncodedSignature = string;
+
+type Base64EncodedMessage = string;
+
+type Base64EncodedSignedMessage = string;
+
+type Base64EncodedSignedTransaction = string;
+
+export type Base64EncodedTransaction = string;
+
+export type Cluster = 'devnet' | 'testnet' | 'mainnet-beta';
+
+export type Finality = 'confirmed' | 'finalized' | 'processed';
+
+export type WalletAssociationConfig = Readonly<{
+    baseUri?: string;
+}>;
+
+export interface AuthorizeAPI {
+    authorize(params: { cluster: Cluster; identity: AppIdentity }): Promise<AuthorizationResult>;
+}
+export interface CloneAuthorizationAPI {
+    cloneAuthorization(params: { auth_token: AuthToken }): Promise<Readonly<{ auth_token: AuthToken }>>;
+}
+export interface DeauthorizeAPI {
+    deauthorize(params: { auth_token: AuthToken }): Promise<Readonly<Record<string, never>>>;
+}
+
+export interface GetCapabilitiesAPI {
+    getCapabilities(): Promise<
+        Readonly<{
+            supports_clone_authorization: boolean;
+            supports_sign_and_send_transactions: boolean;
+            max_transactions_per_request: boolean;
+            max_messages_per_request: boolean;
+            supported_transaction_versions: ReadonlyArray<TransactionVersion>;
+        }>
+    >;
+}
+export interface ReauthorizeAPI {
+    reauthorize(params: { auth_token: AuthToken; identity: AppIdentity }): Promise<AuthorizationResult>;
+}
+export interface SignMessagesAPI {
+    signMessages(params: {
+        addresses: Base64EncodedAddress[];
+        payloads: Base64EncodedMessage[];
+    }): Promise<Readonly<{ signed_payloads: Base64EncodedSignedMessage[] }>>;
+}
+export interface SignTransactionsAPI {
+    signTransactions(params: {
+        payloads: Base64EncodedTransaction[];
+    }): Promise<Readonly<{ signed_payloads: Base64EncodedSignedTransaction[] }>>;
+}
+export interface SignAndSendTransactionsAPI {
+    signAndSendTransactions(params: {
+        options?: Readonly<{
+            min_context_slot?: number;
+        }>;
+        payloads: Base64EncodedTransaction[];
+    }): Promise<Readonly<{ signatures: Base64EncodedSignature[] }>>;
+}
+
+export interface MobileWallet
+    extends AuthorizeAPI,
+        CloneAuthorizationAPI,
+        DeauthorizeAPI,
+        GetCapabilitiesAPI,
+        ReauthorizeAPI,
+        SignMessagesAPI,
+        SignTransactionsAPI,
+        SignAndSendTransactionsAPI {}