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

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": "0.9.9",
+    "version": "1.0.1",
     "author": "Steven Luscher <steven.luscher@solanamobile.com>",
     "repository": "https://github.com/solana-mobile/mobile-wallet-adapter",
     "license": "Apache-2.0",
@@ -46,6 +46,5 @@
     },
     "peerDependencies": {
         "react-native": ">0.69"
-    },
-    "gitHead": "d03adeaa47d752aaac815300572d1157e2362758"
+    }
 }

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

@@ -0,0 +1,106 @@
+import { NativeModules, Platform } from 'react-native';
+
+import { SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterProtocolError } from '../../errors.js';
+import { MobileWallet, 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' && NativeModules.SolanaMobileWalletAdapter
+        ? NativeModules.SolanaMobileWalletAdapter
+        : 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,
+                      );
+                  },
+              },
+          );
+
+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 {
+        await SolanaMobileWalletAdapter.startSession(config);
+        didSuccessfullyConnect = true;
+        const wallet = new Proxy<MobileWallet>({} as MobileWallet, {
+            get<TMethodName extends keyof MobileWallet>(target: MobileWallet, p: TMethodName) {
+                if (target[p] == null) {
+                    const method = p
+                        .toString()
+                        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+                        .toLowerCase();
+                    target[p] = async function (params: Parameters<MobileWallet[TMethodName]>[0]) {
+                        try {
+                            return await SolanaMobileWalletAdapter.invoke(method, params);
+                        } catch (e) {
+                            return handleError(e);
+                        }
+                    } as MobileWallet[TMethodName];
+                }
+                return target[p];
+            },
+            defineProperty() {
+                return false;
+            },
+            deleteProperty() {
+                return false;
+            },
+        });
+        return await callback(wallet);
+    } catch (e) {
+        return handleError(e);
+    } finally {
+        if (didSuccessfullyConnect) {
+            await SolanaMobileWalletAdapter.endSession();
+        }
+    }
+}

package/src/arrayBufferToBase64String.ts

@@ -0,0 +1,10 @@
+// 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

@@ -0,0 +1,19 @@
+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/createHelloReq.ts

@@ -0,0 +1,12 @@
+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;
+}

package/src/createSequenceNumberVector.ts

@@ -0,0 +1,11 @@
+export const SEQUENCE_NUMBER_BYTES = 4;
+
+export default function createSequenceNumberVector(sequenceNumber: number): Uint8Array {
+    if (sequenceNumber >= 4294967296) {
+        throw new Error('Outbound sequence number overflow. The maximum sequence number is 32-bytes.');
+    }
+    const byteArray = new ArrayBuffer(SEQUENCE_NUMBER_BYTES);
+    const view = new DataView(byteArray);
+    view.setUint32(0, sequenceNumber, /* littleEndian */ false);
+    return new Uint8Array(byteArray);
+}

package/src/errors.ts

@@ -0,0 +1,93 @@
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+export const SolanaMobileWalletAdapterErrorCode = {
+    ERROR_ASSOCIATION_PORT_OUT_OF_RANGE: 'ERROR_ASSOCIATION_PORT_OUT_OF_RANGE',
+    ERROR_FORBIDDEN_WALLET_BASE_URL: 'ERROR_FORBIDDEN_WALLET_BASE_URL',
+    ERROR_SECURE_CONTEXT_REQUIRED: 'ERROR_SECURE_CONTEXT_REQUIRED',
+    ERROR_SESSION_CLOSED: 'ERROR_SESSION_CLOSED',
+    ERROR_SESSION_TIMEOUT: 'ERROR_SESSION_TIMEOUT',
+    ERROR_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
+} as const;
+type SolanaMobileWalletAdapterErrorCodeEnum =
+    typeof SolanaMobileWalletAdapterErrorCode[keyof typeof SolanaMobileWalletAdapterErrorCode];
+
+type ErrorDataTypeMap = {
+    [SolanaMobileWalletAdapterErrorCode.ERROR_ASSOCIATION_PORT_OUT_OF_RANGE]: {
+        port: number;
+    };
+    [SolanaMobileWalletAdapterErrorCode.ERROR_FORBIDDEN_WALLET_BASE_URL]: undefined;
+    [SolanaMobileWalletAdapterErrorCode.ERROR_SECURE_CONTEXT_REQUIRED]: undefined;
+    [SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED]: {
+        closeEvent: CloseEvent;
+    };
+    [SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT]: undefined;
+    [SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND]: undefined;
+};
+
+export class SolanaMobileWalletAdapterError<TErrorCode extends SolanaMobileWalletAdapterErrorCodeEnum> extends Error {
+    data: ErrorDataTypeMap[TErrorCode] | undefined;
+    code: TErrorCode;
+    constructor(
+        ...args: ErrorDataTypeMap[TErrorCode] extends Record<string, unknown>
+            ? [code: TErrorCode, message: string, data: ErrorDataTypeMap[TErrorCode]]
+            : [code: TErrorCode, message: string]
+    ) {
+        const [code, message, data] = args;
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'SolanaMobileWalletAdapterError';
+    }
+}
+
+type JSONRPCErrorCode = number;
+
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+export const SolanaMobileWalletAdapterProtocolErrorCode = {
+    // Keep these in sync with `mobilewalletadapter/common/ProtocolContract.java`.
+    ERROR_AUTHORIZATION_FAILED: -1,
+    ERROR_INVALID_PAYLOADS: -2,
+    ERROR_NOT_SIGNED: -3,
+    ERROR_NOT_SUBMITTED: -4,
+    ERROR_TOO_MANY_PAYLOADS: -5,
+    ERROR_ATTEST_ORIGIN_ANDROID: -100,
+} as const;
+type SolanaMobileWalletAdapterProtocolErrorCodeEnum =
+    typeof SolanaMobileWalletAdapterProtocolErrorCode[keyof typeof SolanaMobileWalletAdapterProtocolErrorCode];
+
+type ProtocolErrorDataTypeMap = {
+    [SolanaMobileWalletAdapterProtocolErrorCode.ERROR_AUTHORIZATION_FAILED]: undefined;
+    [SolanaMobileWalletAdapterProtocolErrorCode.ERROR_INVALID_PAYLOADS]: undefined;
+    [SolanaMobileWalletAdapterProtocolErrorCode.ERROR_NOT_SIGNED]: undefined;
+    [SolanaMobileWalletAdapterProtocolErrorCode.ERROR_NOT_SUBMITTED]: undefined;
+    [SolanaMobileWalletAdapterProtocolErrorCode.ERROR_TOO_MANY_PAYLOADS]: undefined;
+    [SolanaMobileWalletAdapterProtocolErrorCode.ERROR_ATTEST_ORIGIN_ANDROID]: {
+        attest_origin_uri: string;
+        challenge: string;
+        context: string;
+    };
+};
+
+export class SolanaMobileWalletAdapterProtocolError<
+    TErrorCode extends SolanaMobileWalletAdapterProtocolErrorCodeEnum,
+> extends Error {
+    data: ProtocolErrorDataTypeMap[TErrorCode] | undefined;
+    code: TErrorCode | JSONRPCErrorCode;
+    jsonRpcMessageId: number;
+    constructor(
+        ...args: ProtocolErrorDataTypeMap[TErrorCode] extends Record<string, unknown>
+            ? [
+                  jsonRpcMessageId: number,
+                  code: TErrorCode | JSONRPCErrorCode,
+                  message: string,
+                  data: ProtocolErrorDataTypeMap[TErrorCode],
+              ]
+            : [jsonRpcMessageId: number, code: TErrorCode | JSONRPCErrorCode, message: string]
+    ) {
+        const [jsonRpcMessageId, code, message, data] = args;
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.jsonRpcMessageId = jsonRpcMessageId;
+        this.name = 'SolanaMobileWalletAdapterProtocolError';
+    }
+}

package/src/generateAssociationKeypair.ts

@@ -0,0 +1,10 @@
+export default async function generateAssociationKeypair(): Promise<CryptoKeyPair> {
+    return await crypto.subtle.generateKey(
+        {
+            name: 'ECDSA',
+            namedCurve: 'P-256',
+        },
+        false /* extractable */,
+        ['sign'] /* keyUsages */,
+    );
+}

package/src/generateECDHKeypair.ts

@@ -0,0 +1,10 @@
+export default async function generateECDHKeypair(): Promise<CryptoKeyPair> {
+    return await crypto.subtle.generateKey(
+        {
+            name: 'ECDH',
+            namedCurve: 'P-256',
+        },
+        false /* extractable */,
+        ['deriveKey', 'deriveBits'] /* keyUsages */,
+    );
+}