@solana-mobile/mobile-wallet-adapter-protocol 2.2.0-new-arch-beta → 2.2.0

package/lib/cjs/index.js

@@ -14,6 +14,7 @@ const SolanaMobileWalletAdapterErrorCode = {
     ERROR_SESSION_TIMEOUT: 'ERROR_SESSION_TIMEOUT',
     ERROR_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
     ERROR_INVALID_PROTOCOL_VERSION: 'ERROR_INVALID_PROTOCOL_VERSION',
+    ERROR_BROWSER_NOT_SUPPORTED: 'ERROR_BROWSER_NOT_SUPPORTED',
 };
 class SolanaMobileWalletAdapterError extends Error {
     constructor(...args) {
@@ -70,6 +71,27 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+function encode(input) {
+    return window.btoa(input);
+}
+function fromUint8Array(byteArray, urlsafe) {
+    const base64 = window.btoa(String.fromCharCode.call(null, ...byteArray));
+    if (urlsafe) {
+        return base64
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    else
+        return base64;
+}
+function toUint8Array(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+
 function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const publicKeyBuffer = yield crypto.subtle.exportKey('raw', ecdhPublicKey);
@@ -81,10 +103,6 @@ function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
     });
 }
 
-function encode(input) {
-    return window.btoa(input);
-}
-
 function createSIWSMessage(payload) {
     return walletStandardUtil.createSignInMessageText(payload);
 }
@@ -107,6 +125,13 @@ const SolanaSignInWithSolana = 'solana:signInWithSolana';
 function createMobileWalletProxy(protocolVersion, protocolRequestHandler) {
     return new Proxy({}, {
         get(target, p) {
+            // Wrapping a Proxy in a promise results in the Proxy being asked for a 'then' property so must 
+            // return null if 'then' is called on this proxy to let the 'resolve()' call know this is not a promise.
+            // see: https://stackoverflow.com/a/53890904
+            //@ts-ignore
+            if (p === 'then') {
+                return null;
+            }
             if (target[p] == null) {
                 target[p] = function (inputParams) {
                     return __awaiter(this, void 0, void 0, function* () {
@@ -320,66 +345,15 @@ function generateECDHKeypair() {
     });
 }
 
-function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const plaintext = JSON.stringify(jsonRpcMessage);
-        const sequenceNumber = jsonRpcMessage.id;
-        return encryptMessage(plaintext, sequenceNumber, sharedSecret);
-    });
-}
-function decryptJsonRpcMessage(message, sharedSecret) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const plaintext = yield decryptMessage(message, sharedSecret);
-        const jsonRpcMessage = JSON.parse(plaintext);
-        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
-            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
-        }
-        return jsonRpcMessage;
-    });
-}
-
-function parseHelloRsp(payloadBuffer, // The X9.62-encoded wallet endpoint ephemeral ECDH public keypoint.
-associationPublicKey, ecdhPrivateKey) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [associationPublicKeyBuffer, walletPublicKey] = yield Promise.all([
-            crypto.subtle.exportKey('raw', associationPublicKey),
-            crypto.subtle.importKey('raw', payloadBuffer.slice(0, ENCODED_PUBLIC_KEY_LENGTH_BYTES), { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
-        ]);
-        const sharedSecret = yield crypto.subtle.deriveBits({ name: 'ECDH', public: walletPublicKey }, ecdhPrivateKey, 256);
-        const ecdhSecretKey = yield crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false /* extractable */, ['deriveKey'] /* keyUsages */);
-        const aesKeyMaterialVal = yield crypto.subtle.deriveKey({
-            name: 'HKDF',
-            hash: 'SHA-256',
-            salt: new Uint8Array(associationPublicKeyBuffer),
-            info: new Uint8Array(),
-        }, ecdhSecretKey, { name: 'AES-GCM', length: 128 }, false /* extractable */, ['encrypt', 'decrypt']);
-        return aesKeyMaterialVal;
-    });
-}
-
-function parseSessionProps(message, sharedSecret) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const plaintext = yield decryptMessage(message, sharedSecret);
-        const jsonProperties = JSON.parse(plaintext);
-        let protocolVersion = 'legacy';
-        if (Object.hasOwnProperty.call(jsonProperties, 'v')) {
-            switch (jsonProperties.v) {
-                case 1:
-                case '1':
-                case 'v1':
-                    protocolVersion = 'v1';
-                    break;
-                case 'legacy':
-                    protocolVersion = 'legacy';
-                    break;
-                default:
-                    throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_INVALID_PROTOCOL_VERSION, `Unknown/unsupported protocol version: ${jsonProperties.v}`);
-            }
-        }
-        return ({
-            protocol_version: protocolVersion
-        });
-    });
+// https://stackoverflow.com/a/9458996/802047
+function arrayBufferToBase64String(buffer) {
+    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);
 }
 
 function getRandomAssociationPort() {
@@ -392,17 +366,6 @@ function assertAssociationPort(port) {
     return port;
 }
 
-// https://stackoverflow.com/a/9458996/802047
-function arrayBufferToBase64String(buffer) {
-    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);
-}
-
 function getStringWithURLUnsafeCharactersReplaced(unsafeBase64EncodedString) {
     return unsafeBase64EncodedString.replace(/[/+=]/g, (m) => ({
         '/': '_',
@@ -411,24 +374,6 @@ function getStringWithURLUnsafeCharactersReplaced(unsafeBase64EncodedString) {
     }[m]));
 }
 
-function getRandomReflectorId() {
-    return assertReflectorId(getRandomInt(0, 9007199254740991)); // 0 < id < 2^53 - 1
-}
-function getRandomInt(min, max) {
-    const randomBuffer = new Uint32Array(1);
-    window.crypto.getRandomValues(randomBuffer);
-    let randomNumber = randomBuffer[0] / (0xffffffff + 1);
-    min = Math.ceil(min);
-    max = Math.floor(max);
-    return Math.floor(randomNumber * (max - min + 1)) + min;
-}
-function assertReflectorId(id) {
-    if (id < 0 || id > 9007199254740991) { // 0 < id < 2^53 - 1
-        throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_REFLECTOR_ID_OUT_OF_RANGE, `Association port number must be between 49152 and 65535. ${id} given.`, { id });
-    }
-    return id;
-}
-
 const INTENT_NAME = 'solana-wallet';
 function getPathParts(pathString) {
     return (pathString
@@ -470,15 +415,14 @@ function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associ
         return url;
     });
 }
-function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, putativeId, associationURLBase, protocolVersions = ['v1']) {
+function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, reflectorId, associationURLBase, protocolVersions = ['v1']) {
     return __awaiter(this, void 0, void 0, function* () {
-        const reflectorId = assertReflectorId(putativeId);
         const exportedKey = yield crypto.subtle.exportKey('raw', associationPublicKey);
         const encodedKey = arrayBufferToBase64String(exportedKey);
         const url = getIntentURL('v1/associate/remote', associationURLBase);
         url.searchParams.set('association', getStringWithURLUnsafeCharactersReplaced(encodedKey));
         url.searchParams.set('reflector', `${hostAuthority}`);
-        url.searchParams.set('id', `${reflectorId}`);
+        url.searchParams.set('id', `${fromUint8Array(reflectorId, true)}`);
         protocolVersions.forEach((version) => {
             url.searchParams.set('v', version);
         });
@@ -486,6 +430,68 @@ function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority,
     });
 }
 
+function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = JSON.stringify(jsonRpcMessage);
+        const sequenceNumber = jsonRpcMessage.id;
+        return encryptMessage(plaintext, sequenceNumber, sharedSecret);
+    });
+}
+function decryptJsonRpcMessage(message, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = yield decryptMessage(message, sharedSecret);
+        const jsonRpcMessage = JSON.parse(plaintext);
+        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
+            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
+        }
+        return jsonRpcMessage;
+    });
+}
+
+function parseHelloRsp(payloadBuffer, // The X9.62-encoded wallet endpoint ephemeral ECDH public keypoint.
+associationPublicKey, ecdhPrivateKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [associationPublicKeyBuffer, walletPublicKey] = yield Promise.all([
+            crypto.subtle.exportKey('raw', associationPublicKey),
+            crypto.subtle.importKey('raw', payloadBuffer.slice(0, ENCODED_PUBLIC_KEY_LENGTH_BYTES), { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
+        ]);
+        const sharedSecret = yield crypto.subtle.deriveBits({ name: 'ECDH', public: walletPublicKey }, ecdhPrivateKey, 256);
+        const ecdhSecretKey = yield crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false /* extractable */, ['deriveKey'] /* keyUsages */);
+        const aesKeyMaterialVal = yield crypto.subtle.deriveKey({
+            name: 'HKDF',
+            hash: 'SHA-256',
+            salt: new Uint8Array(associationPublicKeyBuffer),
+            info: new Uint8Array(),
+        }, ecdhSecretKey, { name: 'AES-GCM', length: 128 }, false /* extractable */, ['encrypt', 'decrypt']);
+        return aesKeyMaterialVal;
+    });
+}
+
+function parseSessionProps(message, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = yield decryptMessage(message, sharedSecret);
+        const jsonProperties = JSON.parse(plaintext);
+        let protocolVersion = 'legacy';
+        if (Object.hasOwnProperty.call(jsonProperties, 'v')) {
+            switch (jsonProperties.v) {
+                case 1:
+                case '1':
+                case 'v1':
+                    protocolVersion = 'v1';
+                    break;
+                case 'legacy':
+                    protocolVersion = 'legacy';
+                    break;
+                default:
+                    throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_INVALID_PROTOCOL_VERSION, `Unknown/unsupported protocol version: ${jsonProperties.v}`);
+            }
+        }
+        return ({
+            protocol_version: protocolVersion
+        });
+    });
+}
+
 // Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
 const Browser = {
     Firefox: 0,
@@ -514,7 +520,7 @@ function getDetectionPromise() {
         const timeoutId = setTimeout(() => {
             cleanup();
             reject();
-        }, 2000);
+        }, 3000);
     });
 }
 let _frame = null;
@@ -569,13 +575,6 @@ function startSession(associationPublicKey, associationURLBase) {
         return randomAssociationPort;
     });
 }
-function getRemoteSessionUrl(associationPublicKey, hostAuthority, associationURLBase) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const randomReflectorId = getRandomReflectorId();
-        const associationUrl = yield getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, randomReflectorId, associationURLBase);
-        return { associationUrl, reflectorId: randomReflectorId };
-    });
-}
 
 const WEBSOCKET_CONNECTION_CONFIG = {
     /**
@@ -591,7 +590,8 @@ const WEBSOCKET_CONNECTION_CONFIG = {
     retryDelayScheduleMs: [150, 150, 200, 500, 500, 750, 750, 1000],
     timeoutMs: 30000,
 };
-const WEBSOCKET_PROTOCOL = 'com.solana.mobilewalletadapter.v1';
+const WEBSOCKET_PROTOCOL_BINARY = 'com.solana.mobilewalletadapter.v1';
+const WEBSOCKET_PROTOCOL_BASE64 = 'com.solana.mobilewalletadapter.v1.base64';
 function assertSecureContext() {
     if (typeof window === 'undefined' || window.isSecureContext !== true) {
         throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SECURE_CONTEXT_REQUIRED, 'The mobile wallet adapter protocol must be used in a secure context (`https`).');
@@ -613,6 +613,20 @@ function getSequenceNumberFromByteArray(byteArray) {
     const view = new DataView(byteArray);
     return view.getUint32(0, /* littleEndian */ false);
 }
+function decodeVarLong(byteArray) {
+    var bytes = new Uint8Array(byteArray), l = byteArray.byteLength, limit = 10, value = 0, offset = 0, b;
+    do {
+        if (offset >= l || offset > limit)
+            throw new RangeError('Failed to decode varint');
+        b = bytes[offset++];
+        value |= (b & 0x7F) << (7 * offset);
+    } while (b >= 0x80);
+    return { value, offset };
+}
+function getReflectorIdFromByteArray(byteArray) {
+    let { value: length, offset } = decodeVarLong(byteArray);
+    return new Uint8Array(byteArray.slice(offset, offset + length));
+}
 function transact(callback, config) {
     return __awaiter(this, void 0, void 0, function* () {
         assertSecureContext();
@@ -796,7 +810,7 @@ function transact(callback, config) {
                 if (connectionStartTime === undefined) {
                     connectionStartTime = Date.now();
                 }
-                socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL]);
+                socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL_BINARY]);
                 socket.addEventListener('open', handleOpen);
                 socket.addEventListener('close', handleClose);
                 socket.addEventListener('error', handleError);
@@ -813,12 +827,11 @@ function transact(callback, config) {
         });
     });
 }
-function transactRemote(callback, config) {
+function startRemoteScenario(config) {
     return __awaiter(this, void 0, void 0, function* () {
         assertSecureContext();
         const associationKeypair = yield generateAssociationKeypair();
-        const { associationUrl, reflectorId } = yield getRemoteSessionUrl(associationKeypair.publicKey, config.remoteHostAuthority, config === null || config === void 0 ? void 0 : config.baseUri);
-        const websocketURL = `wss://${config === null || config === void 0 ? void 0 : config.remoteHostAuthority}/reflect?id=${reflectorId}`;
+        const websocketURL = `wss://${config === null || config === void 0 ? void 0 : config.remoteHostAuthority}/reflect`;
         let connectionStartTime;
         const getNextRetryDelayMs = (() => {
             const schedule = [...WEBSOCKET_CONNECTION_CONFIG.retryDelayScheduleMs];
@@ -826,50 +839,125 @@ function transactRemote(callback, config) {
         })();
         let nextJsonRpcMessageId = 1;
         let lastKnownInboundSequenceNumber = 0;
+        let encoding;
         let state = { __type: 'disconnected' };
-        return { associationUrl, result: new Promise((resolve, reject) => {
-                let socket;
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const jsonRpcResponsePromises = {};
-                const handleOpen = () => __awaiter(this, void 0, void 0, function* () {
-                    if (state.__type !== 'connecting') {
-                        console.warn('Expected adapter state to be `connecting` at the moment the websocket opens. ' +
-                            `Got \`${state.__type}\`.`);
-                        return;
-                    }
-                    socket.removeEventListener('open', handleOpen);
-                });
-                const handleClose = (evt) => {
-                    if (evt.wasClean) {
-                        state = { __type: 'disconnected' };
-                    }
-                    else {
-                        reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session dropped unexpectedly (${evt.code}: ${evt.reason}).`, { closeEvent: evt }));
+        let socket;
+        let disposeSocket;
+        let decodeBytes = (evt) => __awaiter(this, void 0, void 0, function* () {
+            if (encoding == 'base64') { // base64 encoding
+                const message = yield evt.data;
+                return toUint8Array(message).buffer;
+            }
+            else {
+                return yield evt.data.arrayBuffer();
+            }
+        });
+        // Reflector Connection Phase
+        // here we connect to the reflector and wait for the REFLECTOR_ID message 
+        // so we build the association URL and return that back to the caller
+        const associationUrl = yield new Promise((resolve, reject) => {
+            const handleOpen = () => __awaiter(this, void 0, void 0, function* () {
+                if (state.__type !== 'connecting') {
+                    console.warn('Expected adapter state to be `connecting` at the moment the websocket opens. ' +
+                        `Got \`${state.__type}\`.`);
+                    return;
+                }
+                if (socket.protocol.includes(WEBSOCKET_PROTOCOL_BASE64)) {
+                    encoding = 'base64';
+                }
+                else {
+                    encoding = 'binary';
+                }
+                socket.removeEventListener('open', handleOpen);
+            });
+            const handleClose = (evt) => {
+                if (evt.wasClean) {
+                    state = { __type: 'disconnected' };
+                }
+                else {
+                    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 (Date.now() - connectionStartTime >= WEBSOCKET_CONNECTION_CONFIG.timeoutMs) {
+                    reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT, `Failed to connect to the wallet websocket at ${websocketURL}.`));
+                }
+                else {
+                    yield new Promise((resolve) => {
+                        const retryDelayMs = getNextRetryDelayMs();
+                        retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
+                    });
+                    attemptSocketConnection();
+                }
+            });
+            const handleReflectorIdMessage = (evt) => __awaiter(this, void 0, void 0, function* () {
+                const responseBuffer = yield decodeBytes(evt);
+                if (state.__type === 'connecting') {
+                    if (responseBuffer.byteLength == 0) {
+                        throw new Error('Encountered unexpected message while connecting');
                     }
+                    const reflectorId = getReflectorIdFromByteArray(responseBuffer);
+                    state = {
+                        __type: 'reflector_id_received',
+                        reflectorId: reflectorId
+                    };
+                    const associationUrl = yield getRemoteAssociateAndroidIntentURL(associationKeypair.publicKey, config.remoteHostAuthority, reflectorId, config === null || config === void 0 ? void 0 : config.baseUri);
+                    socket.removeEventListener('message', handleReflectorIdMessage);
+                    resolve(associationUrl);
+                }
+            });
+            let retryWaitTimeoutId;
+            const attemptSocketConnection = () => {
+                if (disposeSocket) {
                     disposeSocket();
+                }
+                state = { __type: 'connecting', associationKeypair };
+                if (connectionStartTime === undefined) {
+                    connectionStartTime = Date.now();
+                }
+                socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL_BINARY, WEBSOCKET_PROTOCOL_BASE64]);
+                socket.addEventListener('open', handleOpen);
+                socket.addEventListener('close', handleClose);
+                socket.addEventListener('error', handleError);
+                socket.addEventListener('message', handleReflectorIdMessage);
+                disposeSocket = () => {
+                    window.clearTimeout(retryWaitTimeoutId);
+                    socket.removeEventListener('open', handleOpen);
+                    socket.removeEventListener('close', handleClose);
+                    socket.removeEventListener('error', handleError);
+                    socket.removeEventListener('message', handleReflectorIdMessage);
                 };
-                const handleError = (_evt) => __awaiter(this, void 0, void 0, function* () {
-                    disposeSocket();
-                    if (Date.now() - connectionStartTime >= WEBSOCKET_CONNECTION_CONFIG.timeoutMs) {
-                        reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT, `Failed to connect to the wallet websocket at ${websocketURL}.`));
-                    }
-                    else {
-                        yield new Promise((resolve) => {
-                            const retryDelayMs = getNextRetryDelayMs();
-                            retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
-                        });
-                        attemptSocketConnection();
-                    }
-                });
+            };
+            attemptSocketConnection();
+        });
+        // Wallet Connection Phase
+        // here we return the association URL (containing the reflector ID) to the caller + 
+        // a promise that will resolve the MobileWallet object once the wallet connects.
+        let sessionEstablished = false;
+        let handleClose;
+        return { associationUrl, close: () => {
+                socket.close();
+                handleClose();
+            }, wallet: new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const jsonRpcResponsePromises = {};
                 const handleMessage = (evt) => __awaiter(this, void 0, void 0, function* () {
-                    const responseBuffer = yield evt.data.arrayBuffer();
+                    const responseBuffer = yield decodeBytes(evt);
                     switch (state.__type) {
-                        case 'connecting':
+                        case 'reflector_id_received':
                             if (responseBuffer.byteLength !== 0) {
-                                throw new Error('Encountered unexpected message while connecting');
+                                throw new Error('Encountered unexpected message while awaiting reflection');
                             }
                             const ecdhKeypair = yield generateECDHKeypair();
-                            socket.send(yield createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
+                            const binaryMsg = yield createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey);
+                            if (encoding == 'base64') {
+                                socket.send(fromUint8Array(binaryMsg));
+                            }
+                            else {
+                                socket.send(binaryMsg);
+                            }
                             state = {
                                 __type: 'hello_req_sent',
                                 associationPublicKey: associationKeypair.publicKey,
@@ -916,12 +1004,18 @@ function transactRemote(callback, config) {
                             state = { __type: 'connected', sharedSecret, sessionProperties };
                             const wallet = createMobileWalletProxy(sessionProperties.protocol_version, (method, params) => __awaiter(this, void 0, void 0, function* () {
                                 const id = nextJsonRpcMessageId++;
-                                socket.send(yield encryptJsonRpcMessage({
+                                const binaryMsg = yield encryptJsonRpcMessage({
                                     id,
                                     jsonrpc: '2.0',
                                     method,
                                     params: params !== null && params !== void 0 ? params : {},
-                                }, sharedSecret));
+                                }, sharedSecret);
+                                if (encoding == 'base64') {
+                                    socket.send(fromUint8Array(binaryMsg));
+                                }
+                                else {
+                                    socket.send(binaryMsg);
+                                }
                                 return new Promise((resolve, reject) => {
                                     jsonRpcResponsePromises[id] = {
                                         resolve(result) {
@@ -947,22 +1041,9 @@ function transactRemote(callback, config) {
                                     };
                                 });
                             }));
+                            sessionEstablished = true;
                             try {
-                                resolve(yield callback(new Proxy(wallet, {
-                                    get(target, p) {
-                                        if (p == 'terminateSession') {
-                                            return function () {
-                                                return __awaiter(this, void 0, void 0, function* () {
-                                                    disposeSocket();
-                                                    socket.close();
-                                                    return;
-                                                });
-                                            };
-                                        }
-                                        else
-                                            return target[p];
-                                    },
-                                })));
+                                resolve(wallet);
                             }
                             catch (e) {
                                 reject(e);
@@ -971,30 +1052,14 @@ function transactRemote(callback, config) {
                         }
                     }
                 });
-                let disposeSocket;
-                let retryWaitTimeoutId;
-                const attemptSocketConnection = () => {
-                    if (disposeSocket) {
-                        disposeSocket();
-                    }
-                    state = { __type: 'connecting', associationKeypair };
-                    if (connectionStartTime === undefined) {
-                        connectionStartTime = Date.now();
+                socket.addEventListener('message', handleMessage);
+                handleClose = () => {
+                    socket.removeEventListener('message', handleMessage);
+                    disposeSocket();
+                    if (!sessionEstablished) {
+                        reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_CLOSED, `The wallet session was closed before connection.`, { closeEvent: new CloseEvent('socket was closed before connection') }));
                     }
-                    socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL]);
-                    socket.addEventListener('open', handleOpen);
-                    socket.addEventListener('close', handleClose);
-                    socket.addEventListener('error', handleError);
-                    socket.addEventListener('message', handleMessage);
-                    disposeSocket = () => {
-                        window.clearTimeout(retryWaitTimeoutId);
-                        socket.removeEventListener('open', handleOpen);
-                        socket.removeEventListener('close', handleClose);
-                        socket.removeEventListener('error', handleError);
-                        socket.removeEventListener('message', handleMessage);
-                    };
                 };
-                attemptSocketConnection();
             }) };
     });
 }
@@ -1006,5 +1071,5 @@ exports.SolanaMobileWalletAdapterProtocolError = SolanaMobileWalletAdapterProtoc
 exports.SolanaMobileWalletAdapterProtocolErrorCode = SolanaMobileWalletAdapterProtocolErrorCode;
 exports.SolanaSignInWithSolana = SolanaSignInWithSolana;
 exports.SolanaSignTransactions = SolanaSignTransactions;
+exports.startRemoteScenario = startRemoteScenario;
 exports.transact = transact;
-exports.transactRemote = transactRemote;

package/lib/cjs/index.native.js

@@ -16,6 +16,7 @@ const SolanaMobileWalletAdapterErrorCode = {
     ERROR_SESSION_TIMEOUT: 'ERROR_SESSION_TIMEOUT',
     ERROR_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
     ERROR_INVALID_PROTOCOL_VERSION: 'ERROR_INVALID_PROTOCOL_VERSION',
+    ERROR_BROWSER_NOT_SUPPORTED: 'ERROR_BROWSER_NOT_SUPPORTED',
 };
 class SolanaMobileWalletAdapterError extends Error {
     constructor(...args) {
@@ -96,6 +97,13 @@ const SolanaSignInWithSolana = 'solana:signInWithSolana';
 function createMobileWalletProxy(protocolVersion, protocolRequestHandler) {
     return new Proxy({}, {
         get(target, p) {
+            // Wrapping a Proxy in a promise results in the Proxy being asked for a 'then' property so must 
+            // return null if 'then' is called on this proxy to let the 'resolve()' call know this is not a promise.
+            // see: https://stackoverflow.com/a/53890904
+            //@ts-ignore
+            if (p === 'then') {
+                return null;
+            }
             if (target[p] == null) {
                 target[p] = function (inputParams) {
                     return __awaiter(this, void 0, void 0, function* () {