@solana-mobile/mobile-wallet-adapter-protocol 2.2.2 → 2.2.3

package/android/build.gradle

@@ -8,7 +8,7 @@ buildscript {
   }
 
   dependencies {
-    classpath 'com.android.tools.build:gradle:8.10.1'
+    classpath 'com.android.tools.build:gradle:8.12.0'
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
@@ -144,7 +144,7 @@ def kotlin_version = getExtOrDefault('kotlinVersion')
 dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"  // From node_modules
-  implementation "com.solanamobile:mobile-wallet-adapter-clientlib:2.0.7"
+  implementation "com.solanamobile:mobile-wallet-adapter-clientlib:2.0.8"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
 }

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

@@ -6,6 +6,8 @@ import android.content.Intent
 import android.net.Uri
 import android.util.Log
 import com.facebook.react.bridge.*
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.jstasks.HeadlessJsTaskContext
 import com.solana.mobilewalletadapter.clientlib.protocol.JsonRpc20Client
 import com.solana.mobilewalletadapter.clientlib.protocol.MobileWalletAdapterClient
 import com.solana.mobilewalletadapter.clientlib.scenario.LocalAssociationIntentCreator
@@ -21,40 +23,49 @@ import kotlinx.coroutines.sync.Mutex
 import org.json.JSONObject
 
 class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
-        SolanaMobileWalletAdapterSpec(reactContext), CoroutineScope {
+    SolanaMobileWalletAdapterSpec(reactContext), CoroutineScope {
 
     data class SessionState(
-            val client: MobileWalletAdapterClient,
-            val localAssociation: LocalAssociationScenario,
+        val client: MobileWalletAdapterClient,
+        val localAssociation: LocalAssociationScenario,
     )
 
     override val coroutineContext =
-            Dispatchers.IO + CoroutineName("SolanaMobileWalletAdapterModuleScope") + SupervisorJob()
+        Dispatchers.IO + CoroutineName("SolanaMobileWalletAdapterModuleScope") + SupervisorJob()
 
     companion object {
         const val NAME = "SolanaMobileWalletAdapter"
+        private const val TAG = "SolanaMobileWalletAdapterModule"
         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 var associationResultCallback: ((Int) -> Unit)? = null
     }
 
+    // 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 var associationResultCallback: ((Int) -> Unit)? = null
+
     private val mActivityEventListener: ActivityEventListener =
-            object : BaseActivityEventListener() {
-                override fun onActivityResult(
-                        activity: Activity?,
-                        requestCode: Int,
-                        resultCode: Int,
-                        data: Intent?
-                ) {
-                    if (requestCode == REQUEST_LOCAL_ASSOCIATION)
-                            associationResultCallback?.invoke(resultCode)
-                }
+        object : BaseActivityEventListener() {
+            override fun onActivityResult(
+                activity: Activity?,
+                requestCode: Int,
+                resultCode: Int,
+                data: Intent?
+            ) {
+                if (requestCode == REQUEST_LOCAL_ASSOCIATION)
+                    associationResultCallback?.invoke(resultCode)
             }
+        }
+
+    private val sessionBackgroundTaskConfig
+        get() = HeadlessJsTaskConfig(
+            taskKey = "SolanaMobileWalletAdapterSessionBackgroundTask",
+            timeout = 0,
+            data = Arguments.createMap(),
+            isAllowedInForeground = true
+        )
 
     init {
         reactContext.addActivityEventListener(mActivityEventListener)
@@ -68,67 +79,87 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
     override fun startSession(config: ReadableMap?, promise: Promise): Unit {
         launch {
             mutex.lock()
-            Log.d(name, "startSession with config $config")
+            Log.d(TAG, "startSession with config $config")
+            var sessionTaskId: Int? = null
+            val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactApplicationContext)
+            val finishHeadlessTask = { taskId: Int? ->
+                try {
+                    if (taskId != null && headlessJsTaskContext.isTaskRunning(taskId)) {
+                        headlessJsTaskContext.finishTask(taskId)
+                    }
+                } catch (e: Exception) {
+                    Log.w(TAG, "Failed to finish headless JS task", e)
+                }
+            }
             try {
                 val uriPrefix = config?.getString("baseUri")?.let { Uri.parse(it) }
                 val localAssociation =
-                        LocalAssociationScenario(
-                                CLIENT_TIMEOUT_MS,
-                        )
+                    LocalAssociationScenario(
+                        CLIENT_TIMEOUT_MS,
+                    )
                 val intent =
-                        LocalAssociationIntentCreator.createAssociationIntent(
-                                uriPrefix,
-                                localAssociation.port,
-                                localAssociation.session
-                        )
+                    LocalAssociationIntentCreator.createAssociationIntent(
+                        uriPrefix,
+                        localAssociation.port,
+                        localAssociation.session
+                    )
+                withContext(Dispatchers.Main) {
+                    sessionTaskId = headlessJsTaskContext.startTask(sessionBackgroundTaskConfig)
+                }
                 associationResultCallback = { resultCode ->
                     if (resultCode == Activity.RESULT_CANCELED) {
-                        Log.d(name, "Local association cancelled by user, ending session")
+                        Log.d(TAG, "Local association cancelled by user, ending session")
                         promise.reject(
-                                "Session not established: Local association cancelled by user",
-                                LocalAssociationScenario.ConnectionFailedException(
-                                        "Local association cancelled by user"
-                                )
+                            "Session not established: Local association cancelled by user",
+                            LocalAssociationScenario.ConnectionFailedException(
+                                "Local association cancelled by user"
+                            )
                         )
                         localAssociation.close()
                     }
+
+                    // stop the headless js task, regardless if the association was successful or not
+                    finishHeadlessTask(sessionTaskId)
                 }
                 currentActivity?.startActivityForResult(intent, REQUEST_LOCAL_ASSOCIATION)
-                        ?: 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)
+                    ?: 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)
                 val sessionPropertiesMap: WritableMap = WritableNativeMap()
                 sessionPropertiesMap.putString(
-                        "protocol_version",
-                        when (localAssociation.session.sessionProperties.protocolVersion) {
-                            ProtocolVersion.LEGACY -> "legacy"
-                            ProtocolVersion.V1 -> "v1"
-                        }
+                    "protocol_version",
+                    when (localAssociation.session.sessionProperties.protocolVersion) {
+                        ProtocolVersion.LEGACY -> "legacy"
+                        ProtocolVersion.V1 -> "v1"
+                    }
                 )
                 promise.resolve(sessionPropertiesMap)
             } catch (e: ActivityNotFoundException) {
-                Log.e(name, "Found no installed wallet that supports the mobile wallet protocol", e)
+                Log.e(TAG, "Found no installed wallet that supports the mobile wallet protocol", e)
+                finishHeadlessTask(sessionTaskId)
                 cleanup()
                 promise.reject("ERROR_WALLET_NOT_FOUND", e)
             } catch (e: TimeoutException) {
-                Log.e(name, "Timed out waiting for local association to be ready", e)
+                Log.e(TAG, "Timed out waiting for local association to be ready", e)
+                finishHeadlessTask(sessionTaskId)
                 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)
+                Log.w(TAG, "Interrupted while waiting for local association to be ready", e)
+                finishHeadlessTask(sessionTaskId)
                 cleanup()
                 promise.reject(e)
             } catch (e: ExecutionException) {
-                Log.e(name, "Failed establishing local association with wallet", e.cause)
+                Log.e(TAG, "Failed establishing local association with wallet", e.cause)
+                finishHeadlessTask(sessionTaskId)
                 cleanup()
                 promise.reject(e)
             } catch (e: Throwable) {
-                Log.e(name, "Failed to start session", e)
+                Log.e(TAG, "Failed to start session", e)
+                finishHeadlessTask(sessionTaskId)
                 cleanup()
                 promise.reject(e)
             }
@@ -137,58 +168,54 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     override fun invoke(method: String, params: ReadableMap?, promise: Promise): Unit =
-            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 if (cause is TimeoutException) {
-                        promise.reject("Timed out waiting for response", e)
-                    } else {
-                        throw e
-                    }
-                } catch (e: Throwable) {
-                    Log.e(name, "Failed to invoke `$method` with params $params", e)
-                    promise.reject(e)
+        sessionState?.let {
+            Log.d(TAG, "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 if (cause is TimeoutException) {
+                    promise.reject("Timed out waiting for response", e)
+                } else {
+                    throw e
                 }
+            } catch (e: Throwable) {
+                Log.e(TAG, "Failed to invoke `$method` with params $params", e)
+                promise.reject(e)
             }
-                    ?: throw NullPointerException(
-                            "Tried to invoke `$method` without an active session"
-                    )
+        } ?: throw NullPointerException(
+            "Tried to invoke `$method` without an active session"
+        )
 
     @ReactMethod
     override fun endSession(promise: Promise): Unit {
         sessionState?.let {
             launch {
-                Log.d(name, "endSession")
+                Log.d(TAG, "endSession")
                 try {
                     it.localAssociation
-                            .close()
-                            .get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
+                        .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)
+                    Log.e(TAG, "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)
+                    Log.e(TAG, "Failed to end session", e)
                     cleanup()
                     promise.reject("Failed to end session", e)
                 }
             }
-        }
-                ?: throw NullPointerException("Tried to end a session without an active session")
+        } ?: throw NullPointerException("Tried to end a session without an active session")
     }
 
     private fun cleanup() {

package/lib/cjs/index.native.js

@@ -247,6 +247,14 @@ function signInFallback(signInPayload, authorizationResult, protocolRequestHandl
     });
 }
 
+reactNative.AppRegistry.registerHeadlessTask('SolanaMobileWalletAdapterSessionBackgroundTask', () => {
+    return () => __awaiter(void 0, void 0, void 0, function* () {
+        // This is a no-op task that is used to keep the app alive while the session is active.
+        // The actual session management is handled in the native module.
+        // This is necessary for the React Native Android implementation to work correctly.
+        // The task is started before startActivityResult and stopped when the activity result callback is triggered
+    });
+});
 const LINKING_ERROR = `The package 'solana-mobile-wallet-adapter-protocol' doesn't seem to be linked. Make sure: \n\n` +
     '- You rebuilt the app after installing the package\n' +
     '- If you are using Lerna workspaces\n' +

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": "2.2.2",
+    "version": "2.2.3",
     "author": "Steven Luscher <steven.luscher@solanamobile.com>",
     "repository": {
         "type": "git",

package/.gitignore

@@ -1,2 +0,0 @@
-lib/
-android/build

package/android/.gitignore

@@ -1,14 +0,0 @@
-# OSX
-#
-.DS_Store
-
-# Android/IJ
-#
-.classpath
-.cxx
-.gradle
-.idea
-.project
-.settings
-local.properties
-android.iml

package/src/__forks__/react-native/base64Utils.ts

@@ -1 +0,0 @@
-export { encode, fromUint8Array, toUint8Array } from 'js-base64';

package/src/__forks__/react-native/transact.ts

@@ -1,91 +0,0 @@
-import { Platform } from 'react-native';
-
-import NativeSolanaMobileWalletAdapter from '../../codegenSpec/NativeSolanaMobileWalletAdapter.js';
-import createMobileWalletProxy from '../../createMobileWalletProxy.js';
-import { SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolError } from '../../errors.js';
-import { MobileWallet, SessionProperties, WalletAssociationConfig } from '../../types.js';
-
-type ReactNativeError = Error & { code?: string; userInfo?: Record<string, unknown> };
-
-const LINKING_ERROR =
-    `The package 'solana-mobile-wallet-adapter-protocol' doesn't seem to be linked. Make sure: \n\n` +
-    '- You rebuilt the app after installing the package\n' +
-    '- If you are using Lerna workspaces\n' +
-    '  - You have added `@solana-mobile/mobile-wallet-adapter-protocol` as an explicit dependency, and\n' +
-    '  - You have added `@solana-mobile/mobile-wallet-adapter-protocol` to the `nohoist` section of your package.json\n' +
-    '- You are not using Expo managed workflow\n';
-
-const SolanaMobileWalletAdapter =
-    Platform.OS === 'android' && NativeSolanaMobileWalletAdapter
-        ? NativeSolanaMobileWalletAdapter
-        : (new Proxy(
-              {},
-              {
-                  get() {
-                      throw new Error(
-                          Platform.OS !== 'android'
-                              ? 'The package `solana-mobile-wallet-adapter-protocol` is only compatible with React Native Android'
-                              : LINKING_ERROR,
-                      );
-                  },
-              },
-          ) as typeof NativeSolanaMobileWalletAdapter);
-
-function getErrorMessage(e: ReactNativeError): string {
-    switch (e.code) {
-        case 'ERROR_WALLET_NOT_FOUND':
-            return 'Found no installed wallet that supports the mobile wallet protocol.';
-        default:
-            return e.message;
-    }
-}
-
-function handleError(e: any): never {
-    if (e instanceof Error) {
-        const reactNativeError: ReactNativeError = e;
-        switch (reactNativeError.code) {
-            case undefined:
-                throw e;
-            case 'JSON_RPC_ERROR': {
-                const details = reactNativeError.userInfo as Readonly<{ jsonRpcErrorCode: number }>;
-                throw new SolanaMobileWalletAdapterProtocolError(
-                    0 /* jsonRpcMessageId */,
-                    details.jsonRpcErrorCode,
-                    e.message,
-                );
-            }
-            default:
-                throw new SolanaMobileWalletAdapterError<any>(
-                    reactNativeError.code,
-                    getErrorMessage(reactNativeError),
-                    reactNativeError.userInfo,
-                );
-        }
-    }
-    throw e;
-}
-
-export async function transact<TReturn>(
-    callback: (wallet: MobileWallet) => TReturn,
-    config?: WalletAssociationConfig,
-): Promise<TReturn> {
-    let didSuccessfullyConnect = false;
-    try {
-        const sessionProperties: SessionProperties = await SolanaMobileWalletAdapter.startSession(config);
-        didSuccessfullyConnect = true;
-        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, async (method, params) => {
-            try {
-                return SolanaMobileWalletAdapter.invoke(method, params);
-            } catch (e) {
-                return handleError(e);
-            }
-        });
-        return await callback(wallet);
-    } catch (e) {
-        return handleError(e);
-    } finally {
-        if (didSuccessfullyConnect) {
-            await SolanaMobileWalletAdapter.endSession();
-        }
-    }
-}

package/src/arrayBufferToBase64String.ts

@@ -1,10 +0,0 @@
-// https://stackoverflow.com/a/9458996/802047
-export default function arrayBufferToBase64String(buffer: ArrayBuffer) {
-    let binary = '';
-    const bytes = new Uint8Array(buffer);
-    const len = bytes.byteLength;
-    for (let ii = 0; ii < len; ii++) {
-        binary += String.fromCharCode(bytes[ii]);
-    }
-    return window.btoa(binary);
-}

package/src/associationPort.ts

@@ -1,19 +0,0 @@
-import { SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode } from './errors.js';
-
-declare const tag: unique symbol;
-export type AssociationPort = number & { readonly [tag]: 'AssociationPort' };
-
-export function getRandomAssociationPort(): AssociationPort {
-    return assertAssociationPort(49152 + Math.floor(Math.random() * (65535 - 49152 + 1)));
-}
-
-export function assertAssociationPort(port: number): AssociationPort {
-    if (port < 49152 || port > 65535) {
-        throw new SolanaMobileWalletAdapterError(
-            SolanaMobileWalletAdapterErrorCode.ERROR_ASSOCIATION_PORT_OUT_OF_RANGE,
-            `Association port number must be between 49152 and 65535. ${port} given.`,
-            { port },
-        );
-    }
-    return port as AssociationPort;
-}

package/src/base64Utils.ts

@@ -1,22 +0,0 @@
-export function encode(input: string): string {
-    return window.btoa(input);
-}
-
-export function fromUint8Array(byteArray: Uint8Array, urlsafe?: boolean): string {
-    const base64 = window.btoa(String.fromCharCode.call(null, ...byteArray));
-    if (urlsafe) {
-        return base64
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=+$/, '');
-    } else return base64;
-}
-
-export function toUint8Array(base64EncodedByteArray: string): Uint8Array {
-    return new Uint8Array(
-        window
-            .atob(base64EncodedByteArray)
-            .split('')
-            .map((c) => c.charCodeAt(0)),
-    );
-}

package/src/createHelloReq.ts

@@ -1,12 +0,0 @@
-export default async function createHelloReq(ecdhPublicKey: CryptoKey, associationKeypairPrivateKey: CryptoKey) {
-    const publicKeyBuffer = await crypto.subtle.exportKey('raw', ecdhPublicKey);
-    const signatureBuffer = await crypto.subtle.sign(
-        { hash: 'SHA-256', name: 'ECDSA' },
-        associationKeypairPrivateKey,
-        publicKeyBuffer,
-    );
-    const response = new Uint8Array(publicKeyBuffer.byteLength + signatureBuffer.byteLength);
-    response.set(new Uint8Array(publicKeyBuffer), 0);
-    response.set(new Uint8Array(signatureBuffer), publicKeyBuffer.byteLength);
-    return response;
-}