@solana-mobile/mobile-wallet-adapter-protocol 0.0.1-alpha.5 → 0.0.1-alpha.8

package/README.md

@@ -1,6 +1,6 @@
 # `@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_message`) as per the spec.
+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.
 
@@ -20,7 +20,7 @@ The callback you provide will be called once a session has been established with
 
 ```typescript
 const signedPayloads = await transact(async (wallet) => {
-    const {signed_payloads} = await wallet('sign_message', {
+    const {signed_payloads} = await wallet.signMessages({
         auth_token,
         payloads: [/* ... */],
     });
@@ -38,18 +38,24 @@ You can catch exceptions at any level. See `errors.ts` for a list of exceptions
 try {
     await transact(async (wallet) => {
         try {
-            await wallet('sign_transaction', /* ... */);
+            await wallet.signTransactions(/* ... */);
         } catch (e) {
-            if (e instanceof SolanaMobileWalletAdapterProtocolReauthorizeError) {
+            if (
+                e instanceof SolanaMobileWalletAdapterProtocolError &&
+                e.code === SolanaMobileWalletAdapterProtocolErrorCode.ERROR_REAUTHORIZE
+            ) {
                 console.error('The auth token has gone stale');
-                await wallet('reauthorize', {auth_token});
+                await wallet.reauthorize({auth_token});
                 // Retry...
             }
             throw e;
         }
     });
 } catch(e) {
-    if (e instanceof SolanaMobileWalletAdapterWalletNotInstalledError) {
+    if (
+        e instanceof SolanaMobileWalletAdapterError &&
+        e.code === SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND
+    ) {
         /* ... */
     }
     throw e;

package/android/build.gradle

@@ -132,7 +132,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:0.1.2"
+  implementation "com.solanamobile:mobile-wallet-adapter-clientlib:0.2.0"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.2"
 }

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

@@ -1,20 +1,21 @@
 package com.solanamobile.mobilewalletadapter.reactnative
 
+import android.content.ActivityNotFoundException
 import android.net.Uri
-import android.os.Looper
 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.solana.mobilewalletadapter.clientlib.scenario.Scenario
 import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertJsonToMap
 import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertMapToJson
 import kotlinx.coroutines.*
 import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.Semaphore
 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 {
@@ -22,7 +23,6 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
     data class SessionState(
         val client: MobileWalletAdapterClient,
         val localAssociation: LocalAssociationScenario,
-        val semSessionTermination: Semaphore,
     )
 
     override val coroutineContext =
@@ -46,38 +46,37 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
         mutex.lock()
         Log.d(name, "startSession with config $config")
         try {
-            val semConnectedOrFailed = Semaphore(1, 1)
-            val semTerminated = Semaphore(1, 1)
             val uriPrefix = config?.getString("baseUri")?.let { Uri.parse(it) }
-            lateinit var localAssociation: LocalAssociationScenario
-            val scenarioCallbacks = object : Scenario.Callbacks {
-                override fun onScenarioReady(client: MobileWalletAdapterClient) {
-                    sessionState = SessionState(client, localAssociation, semTerminated)
-                    semConnectedOrFailed.release()
-                }
-
-                override fun onScenarioError() = semConnectedOrFailed.release()
-                override fun onScenarioComplete() = semConnectedOrFailed.release()
-                override fun onScenarioTeardownComplete() = semTerminated.release()
-            }
-            localAssociation = LocalAssociationScenario(
-                Looper.getMainLooper(),
-                ASSOCIATION_TIMEOUT_MS,
-                scenarioCallbacks,
-                uriPrefix
+            val localAssociation = LocalAssociationScenario(
+                CLIENT_TIMEOUT_MS,
+            )
+            val intent = LocalAssociationIntentCreator.createAssociationIntent(
+                uriPrefix,
+                localAssociation.port,
+                localAssociation.session
             )
-            val intent = localAssociation.createAssociationIntent()
             currentActivity?.startActivityForResult(intent, 0)
                 ?: throw NullPointerException("Could not find a current activity from which to launch a local association")
-            localAssociation.start()
-            withTimeout(ASSOCIATION_TIMEOUT_MS.toLong()) {
-                semConnectedOrFailed.acquire()
-            }
+            val client =
+                localAssociation.start().get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
+            sessionState = SessionState(client, localAssociation)
             promise.resolve(true)
-        } catch (e: TimeoutCancellationException) {
+        } 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()
@@ -116,12 +115,10 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
             Log.d(name, "endSession")
             try {
                 it.localAssociation.close()
-                withTimeout(ASSOCIATION_TIMEOUT_MS.toLong()) {
-                    it.semSessionTermination.acquire()
-                }
+                    .get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
                 cleanup()
                 promise.resolve(true)
-            } catch (e: TimeoutCancellationException) {
+            } catch (e: TimeoutException) {
                 Log.e(name, "Timed out waiting for local association to close", e)
                 cleanup()
                 promise.reject("Failed to end session", e)

package/lib/cjs/index.browser.js

@@ -2,65 +2,41 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-class SolanaMobileWalletAdapterSecureContextRequiredError extends Error {
-    constructor() {
-        super('The mobile wallet adapter protocol must be used in a secure context (`https`).');
-        this.name = 'SolanaMobileWalletAdapterSecureContextRequiredError';
-    }
-}
-class SolanaMobileWalletAdapterForbiddenWalletBaseURLError extends Error {
-    constructor() {
-        super('Base URLs supplied by wallets must be valid `https` URLs');
-        this.name = 'SolanaMobileWalletAdapterForbiddenWalletBaseURLError';
-    }
-}
-class SolanaMobileWalletAdapterWalletNotInstalledError extends Error {
-    constructor() {
-        super(`Found no installed wallet that supports the mobile wallet protocol.`);
-        this.name = 'SolanaMobileWalletAdapterWalletNotInstalledError';
-    }
-}
-class SolanaMobileWalletAdapterProtocolSessionEstablishmentError extends Error {
-    constructor(port) {
-        super(`Failed to connect to the wallet websocket on port ${port}.`);
-        this.name = 'SolanaMobileWalletAdapterProtocolSessionEstablishmentError';
-    }
-}
-class SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError extends Error {
-    constructor(port) {
-        super(`Association port number must be between 49152 and 65535. ${port} given.`);
-        this.name = 'SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError';
-    }
-}
-class SolanaMobileWalletAdapterProtocolSessionClosedError extends Error {
-    constructor(code, reason) {
-        super(`The wallet session dropped unexpectedly (${code}: ${reason}).`);
-        this.name = 'SolanaMobileWalletAdapterProtocolSessionClosedError';
-    }
-}
-class SolanaMobileWalletAdapterProtocolReauthorizeError extends Error {
-    constructor() {
-        super('The auth token provided has gone stale and needs reauthorization.');
-        this.name = 'SolanaMobileWalletAdapterProtocolReauthorizeError';
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+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_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
+};
+class SolanaMobileWalletAdapterError extends Error {
+    constructor(...args) {
+        const [code, message, data] = args;
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'SolanaMobileWalletAdapterError';
     }
 }
 // Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
-const SolanaMobileWalletAdapterProtocolError = {
-    ERROR_REAUTHORIZE: -1,
-    ERROR_AUTHORIZATION_FAILED: -2,
-    ERROR_INVALID_PAYLOAD: -3,
-    ERROR_NOT_SIGNED: -4,
-    ERROR_NOT_COMMITTED: -5,
+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_COMMITTED: -4,
+    ERROR_TOO_MANY_PAYLOADS: -5,
     ERROR_ATTEST_ORIGIN_ANDROID: -100,
 };
-class SolanaMobileWalletAdapterProtocolJsonRpcError extends Error {
+class SolanaMobileWalletAdapterProtocolError extends Error {
     constructor(...args) {
         const [jsonRpcMessageId, code, message, data] = args;
         super(message);
         this.code = code;
         this.data = data;
         this.jsonRpcMessageId = jsonRpcMessageId;
-        this.name = 'SolanaNativeWalletAdapterJsonRpcError';
+        this.name = 'SolanaMobileWalletAdapterProtocolError';
     }
 }
 
@@ -100,6 +76,17 @@ function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
     });
 }
 
+const SEQUENCE_NUMBER_BYTES = 4;
+function createSequenceNumberVector(sequenceNumber) {
+    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);
+}
+
 function generateAssociationKeypair() {
     return __awaiter(this, void 0, void 0, function* () {
         return yield crypto.subtle.generateKey({
@@ -122,30 +109,34 @@ const INITIALIZATION_VECTOR_BYTES = 12;
 function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
     return __awaiter(this, void 0, void 0, function* () {
         const plaintext = JSON.stringify(jsonRpcMessage);
+        const sequenceNumberVector = createSequenceNumberVector(jsonRpcMessage.id);
         const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
         crypto.getRandomValues(initializationVector);
-        const ciphertext = yield crypto.subtle.encrypt(getAlgorithmParams(initializationVector), sharedSecret, Buffer.from(plaintext));
-        const response = new Uint8Array(initializationVector.byteLength + ciphertext.byteLength);
-        response.set(new Uint8Array(initializationVector), 0);
-        response.set(new Uint8Array(ciphertext), initializationVector.byteLength);
+        const ciphertext = yield crypto.subtle.encrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, Buffer.from(plaintext));
+        const response = new Uint8Array(sequenceNumberVector.byteLength + initializationVector.byteLength + ciphertext.byteLength);
+        response.set(new Uint8Array(sequenceNumberVector), 0);
+        response.set(new Uint8Array(initializationVector), sequenceNumberVector.byteLength);
+        response.set(new Uint8Array(ciphertext), sequenceNumberVector.byteLength + initializationVector.byteLength);
         return response;
     });
 }
 function decryptJsonRpcMessage(message, sharedSecret) {
     return __awaiter(this, void 0, void 0, function* () {
-        const initializationVector = message.slice(0, INITIALIZATION_VECTOR_BYTES);
-        const ciphertext = message.slice(INITIALIZATION_VECTOR_BYTES);
-        const plaintextBuffer = yield crypto.subtle.decrypt(getAlgorithmParams(initializationVector), sharedSecret, ciphertext);
+        const sequenceNumberVector = message.slice(0, SEQUENCE_NUMBER_BYTES);
+        const initializationVector = message.slice(SEQUENCE_NUMBER_BYTES, SEQUENCE_NUMBER_BYTES + INITIALIZATION_VECTOR_BYTES);
+        const ciphertext = message.slice(SEQUENCE_NUMBER_BYTES + INITIALIZATION_VECTOR_BYTES);
+        const plaintextBuffer = yield crypto.subtle.decrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, ciphertext);
         const plaintext = getUtf8Decoder().decode(plaintextBuffer);
         const jsonRpcMessage = JSON.parse(plaintext);
         if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
-            throw new SolanaMobileWalletAdapterProtocolJsonRpcError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
+            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
         }
         return jsonRpcMessage;
     });
 }
-function getAlgorithmParams(initializationVector) {
+function getAlgorithmParams(sequenceNumber, initializationVector) {
     return {
+        additionalData: sequenceNumber,
         iv: initializationVector,
         name: 'AES-GCM',
         tagLength: 128, // 16 byte tag => 128 bits
@@ -183,7 +174,7 @@ function getRandomAssociationPort() {
 }
 function assertAssociationPort(port) {
     if (port < 49152 || port > 65535) {
-        throw new SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError(port);
+        throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_ASSOCIATION_PORT_OUT_OF_RANGE, `Association port number must be between 49152 and 65535. ${port} given.`, { port });
     }
     return port;
 }
@@ -223,7 +214,7 @@ function getIntentURL(methodPathname, intentUrlBase) {
         }
         catch (_a) { } // eslint-disable-line no-empty
         if ((baseUrl === null || baseUrl === void 0 ? void 0 : baseUrl.protocol) !== 'https:') {
-            throw new SolanaMobileWalletAdapterForbiddenWalletBaseURLError();
+            throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_FORBIDDEN_WALLET_BASE_URL, 'Base URLs supplied by wallets must be valid `https` URLs');
         }
     }
     baseUrl || (baseUrl = new URL(`${INTENT_NAME}:/`));
@@ -318,7 +309,7 @@ function startSession(associationPublicKey, associationURLBase) {
                 }
             }
             catch (e) {
-                throw new SolanaMobileWalletAdapterWalletNotInstalledError();
+                throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND, 'Found no installed wallet that supports the mobile wallet protocol.');
             }
         }
         return randomAssociationPort;
@@ -326,32 +317,44 @@ function startSession(associationPublicKey, associationURLBase) {
 }
 
 const WEBSOCKET_CONNECTION_CONFIG = {
-    maxAttempts: 34,
     /**
      * 300 milliseconds is a generally accepted threshold for what someone
      * would consider an acceptable response time for a user interface
-     * after having performed a low-attention tapping task. We set the
+     * after having performed a low-attention tapping task. We set the initial
      * interval at which we wait for the wallet to set up the websocket at
-     * half this, as per the Nyquist frequency.
+     * half this, as per the Nyquist frequency, with a progressive backoff
+     * sequence from there. The total wait time is 30s, which allows for the
+     * user to be presented with a disambiguation dialog, select a wallet, and
+     * for the wallet app to subsequently start.
      */
-    retryDelayMs: 150,
+    retryDelayScheduleMs: [150, 150, 200, 500, 500, 750, 750, 1000],
+    timeoutMs: 30000,
 };
 const WEBSOCKET_PROTOCOL = 'com.solana.mobilewalletadapter.v1';
 function assertSecureContext() {
     if (typeof window === 'undefined' || window.isSecureContext !== true) {
-        throw new SolanaMobileWalletAdapterSecureContextRequiredError();
+        throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SECURE_CONTEXT_REQUIRED, 'The mobile wallet adapter protocol must be used in a secure context (`https`).');
     }
 }
+function getSequenceNumberFromByteArray(byteArray) {
+    const view = new DataView(byteArray);
+    return view.getUint32(0, /* littleEndian */ false);
+}
 function transact(callback, config) {
     return __awaiter(this, void 0, void 0, function* () {
         assertSecureContext();
         const associationKeypair = yield generateAssociationKeypair();
         const sessionPort = yield startSession(associationKeypair.publicKey, config === null || config === void 0 ? void 0 : config.baseUri);
         const websocketURL = `ws://localhost:${sessionPort}/solana-wallet`;
+        let connectionStartTime;
+        const getNextRetryDelayMs = (() => {
+            const schedule = [...WEBSOCKET_CONNECTION_CONFIG.retryDelayScheduleMs];
+            return () => (schedule.length > 1 ? schedule.shift() : schedule[0]);
+        })();
         let nextJsonRpcMessageId = 1;
+        let lastKnownInboundSequenceNumber = 0;
         let state = { __type: 'disconnected' };
         return new Promise((resolve, reject) => {
-            let attempts = 0;
             let socket;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const jsonRpcResponsePromises = {};
@@ -376,18 +379,19 @@ function transact(callback, config) {
                     state = { __type: 'disconnected' };
                 }
                 else {
-                    reject(new SolanaMobileWalletAdapterProtocolSessionClosedError(evt.code, evt.reason));
+                    reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session dropped unexpectedly (${evt.code}: ${evt.reason}).`, { closeEvent: evt }));
                 }
                 disposeSocket();
             };
             const handleError = (_evt) => __awaiter(this, void 0, void 0, function* () {
                 disposeSocket();
-                if (++attempts >= WEBSOCKET_CONNECTION_CONFIG.maxAttempts) {
-                    reject(new SolanaMobileWalletAdapterProtocolSessionEstablishmentError(sessionPort));
+                if (Date.now() - connectionStartTime >= WEBSOCKET_CONNECTION_CONFIG.timeoutMs) {
+                    reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND, `Failed to connect to the wallet websocket on port ${sessionPort}.`));
                 }
                 else {
                     yield new Promise((resolve) => {
-                        retryWaitTimeoutId = window.setTimeout(resolve, WEBSOCKET_CONNECTION_CONFIG.retryDelayMs);
+                        const retryDelayMs = getNextRetryDelayMs();
+                        retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
                     });
                     attemptSocketConnection();
                 }
@@ -397,13 +401,19 @@ function transact(callback, config) {
                 switch (state.__type) {
                     case 'connected':
                         try {
+                            const sequenceNumberVector = responseBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
+                            const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
+                            if (sequenceNumber <= lastKnownInboundSequenceNumber) {
+                                throw new Error('Encrypted message has invalid sequence number');
+                            }
+                            lastKnownInboundSequenceNumber = sequenceNumber;
                             const jsonRpcMessage = yield decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
                             const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
                             delete jsonRpcResponsePromises[jsonRpcMessage.id];
                             responsePromise.resolve(jsonRpcMessage.result);
                         }
                         catch (e) {
-                            if (e instanceof SolanaMobileWalletAdapterProtocolJsonRpcError) {
+                            if (e instanceof SolanaMobileWalletAdapterProtocolError) {
                                 const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
                                 delete jsonRpcResponsePromises[e.jsonRpcMessageId];
                                 responsePromise.reject(e);
@@ -416,20 +426,39 @@ function transact(callback, config) {
                     case 'hello_req_sent': {
                         const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
                         state = { __type: 'connected', sharedSecret };
-                        const walletAPI = (method, params) => __awaiter(this, void 0, void 0, function* () {
-                            const id = nextJsonRpcMessageId++;
-                            socket.send(yield encryptJsonRpcMessage({
-                                id,
-                                jsonrpc: '2.0',
-                                method,
-                                params,
-                            }, sharedSecret));
-                            return new Promise((resolve, reject) => {
-                                jsonRpcResponsePromises[id] = { resolve, reject };
-                            });
+                        const wallet = new Proxy({}, {
+                            get(target, p) {
+                                if (target[p] == null) {
+                                    const method = p
+                                        .toString()
+                                        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+                                        .toLowerCase();
+                                    target[p] = function (params) {
+                                        return __awaiter(this, void 0, void 0, function* () {
+                                            const id = nextJsonRpcMessageId++;
+                                            socket.send(yield encryptJsonRpcMessage({
+                                                id,
+                                                jsonrpc: '2.0',
+                                                method,
+                                                params,
+                                            }, sharedSecret));
+                                            return new Promise((resolve, reject) => {
+                                                jsonRpcResponsePromises[id] = { resolve, reject };
+                                            });
+                                        });
+                                    };
+                                }
+                                return target[p];
+                            },
+                            defineProperty() {
+                                return false;
+                            },
+                            deleteProperty() {
+                                return false;
+                            },
                         });
                         try {
-                            resolve(yield callback(walletAPI));
+                            resolve(yield callback(wallet));
                         }
                         catch (e) {
                             reject(e);
@@ -449,6 +478,9 @@ function transact(callback, config) {
                     disposeSocket();
                 }
                 state = { __type: 'connecting', associationKeypair };
+                if (connectionStartTime === undefined) {
+                    connectionStartTime = Date.now();
+                }
                 socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL]);
                 socket.addEventListener('open', handleOpen);
                 socket.addEventListener('close', handleClose);
@@ -467,13 +499,8 @@ function transact(callback, config) {
     });
 }
 
-exports.SolanaMobileWalletAdapterForbiddenWalletBaseURLError = SolanaMobileWalletAdapterForbiddenWalletBaseURLError;
-exports.SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError = SolanaMobileWalletAdapterProtocolAssociationPortOutOfRangeError;
+exports.SolanaMobileWalletAdapterError = SolanaMobileWalletAdapterError;
+exports.SolanaMobileWalletAdapterErrorCode = SolanaMobileWalletAdapterErrorCode;
 exports.SolanaMobileWalletAdapterProtocolError = SolanaMobileWalletAdapterProtocolError;
-exports.SolanaMobileWalletAdapterProtocolJsonRpcError = SolanaMobileWalletAdapterProtocolJsonRpcError;
-exports.SolanaMobileWalletAdapterProtocolReauthorizeError = SolanaMobileWalletAdapterProtocolReauthorizeError;
-exports.SolanaMobileWalletAdapterProtocolSessionClosedError = SolanaMobileWalletAdapterProtocolSessionClosedError;
-exports.SolanaMobileWalletAdapterProtocolSessionEstablishmentError = SolanaMobileWalletAdapterProtocolSessionEstablishmentError;
-exports.SolanaMobileWalletAdapterSecureContextRequiredError = SolanaMobileWalletAdapterSecureContextRequiredError;
-exports.SolanaMobileWalletAdapterWalletNotInstalledError = SolanaMobileWalletAdapterWalletNotInstalledError;
+exports.SolanaMobileWalletAdapterProtocolErrorCode = SolanaMobileWalletAdapterProtocolErrorCode;
 exports.transact = transact;