@solana-mobile/mobile-wallet-adapter-protocol 2.2.5 → 2.2.6

package/lib/esm/index.js

@@ -12,8 +12,12 @@ const SolanaMobileWalletAdapterErrorCode = {
     ERROR_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
     ERROR_INVALID_PROTOCOL_VERSION: 'ERROR_INVALID_PROTOCOL_VERSION',
     ERROR_BROWSER_NOT_SUPPORTED: 'ERROR_BROWSER_NOT_SUPPORTED',
+    ERROR_LOOPBACK_ACCESS_BLOCKED: 'ERROR_LOOPBACK_ACCESS_BLOCKED',
+    ERROR_ASSOCIATION_CANCELLED: 'ERROR_ASSOCIATION_CANCELLED',
 };
 class SolanaMobileWalletAdapterError extends Error {
+    data;
+    code;
     constructor(...args) {
         const [code, message, data] = args;
         super(message);
@@ -33,6 +37,9 @@ const SolanaMobileWalletAdapterProtocolErrorCode = {
     ERROR_ATTEST_ORIGIN_ANDROID: -100,
 };
 class SolanaMobileWalletAdapterProtocolError extends Error {
+    data;
+    code;
+    jsonRpcMessageId;
     constructor(...args) {
         const [jsonRpcMessageId, code, message, data] = args;
         super(message);
@@ -43,31 +50,6 @@ class SolanaMobileWalletAdapterProtocolError extends Error {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
 function encode(input) {
     return window.btoa(input);
 }
@@ -89,15 +71,13 @@ function toUint8Array(base64EncodedByteArray) {
         .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);
-        const signatureBuffer = yield 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;
-    });
+async function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
+    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;
 }
 
 function createSIWSMessage(payload) {
@@ -140,16 +120,14 @@ function createMobileWalletProxy(protocolVersion, protocolRequestHandler) {
                 return null;
             }
             if (target[p] == null) {
-                target[p] = function (inputParams) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const { method, params } = handleMobileWalletRequest(p, inputParams, protocolVersion);
-                        const result = yield protocolRequestHandler(method, params);
-                        // if the request tried to sign in but the wallet did not return a sign in result, fallback on message signing
-                        if (method === 'authorize' && params.sign_in_payload && !result.sign_in_result) {
-                            result['sign_in_result'] = yield signInFallback(params.sign_in_payload, result, protocolRequestHandler);
-                        }
-                        return handleMobileWalletResponse(p, result, protocolVersion);
-                    });
+                target[p] = async function (inputParams) {
+                    const { method, params } = handleMobileWalletRequest(p, inputParams, protocolVersion);
+                    const result = await protocolRequestHandler(method, params);
+                    // if the request tried to sign in but the wallet did not return a sign in result, fallback on message signing
+                    if (method === 'authorize' && params.sign_in_payload && !result.sign_in_result) {
+                        result['sign_in_result'] = await signInFallback(params.sign_in_payload, result, protocolRequestHandler);
+                    }
+                    return handleMobileWalletResponse(p, result, protocolVersion);
                 };
             }
             return target[p];
@@ -253,39 +231,43 @@ function handleMobileWalletResponse(method, response, protocolVersion) {
                     if (capabilities.supports_clone_authorization === true) {
                         features.push(SolanaCloneAuthorization);
                     }
-                    return Object.assign(Object.assign({}, capabilities), { features: features });
+                    return {
+                        ...capabilities,
+                        features: features,
+                    };
                 }
                 case 'v1': {
-                    return Object.assign(Object.assign({}, capabilities), { supports_sign_and_send_transactions: true, supports_clone_authorization: capabilities.features.includes(SolanaCloneAuthorization) });
+                    return {
+                        ...capabilities,
+                        supports_sign_and_send_transactions: true,
+                        supports_clone_authorization: capabilities.features.includes(SolanaCloneAuthorization)
+                    };
                 }
             }
         }
     }
     return response;
 }
-function signInFallback(signInPayload, authorizationResult, protocolRequestHandler) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        const domain = (_a = signInPayload.domain) !== null && _a !== void 0 ? _a : window.location.host;
-        const address = authorizationResult.accounts[0].address;
-        const siwsMessage = createSIWSMessageBase64Url(Object.assign(Object.assign({}, signInPayload), { domain, address: base64ToBase58(address) }));
-        const signMessageResult = yield protocolRequestHandler('sign_messages', {
-            addresses: [address],
-            payloads: [siwsMessage]
-        });
-        const signedPayload = toUint8Array(signMessageResult.signed_payloads[0]);
-        const signedMessage = fromUint8Array$1(signedPayload.slice(0, signedPayload.length - 64));
-        const signature = fromUint8Array$1(signedPayload.slice(signedPayload.length - 64));
-        const signInResult = {
-            address: address,
-            // Workaround: some wallets have been observed to only reply with the message signature.
-            // This is non-compliant with the spec, but in the interest of maximizing compatibility,
-            // detect this case and reuse the original message.
-            signed_message: signedMessage.length == 0 ? siwsMessage : signedMessage,
-            signature
-        };
-        return signInResult;
+async function signInFallback(signInPayload, authorizationResult, protocolRequestHandler) {
+    const domain = signInPayload.domain ?? window.location.host;
+    const address = authorizationResult.accounts[0].address;
+    const siwsMessage = createSIWSMessageBase64Url({ ...signInPayload, domain, address: base64ToBase58(address) });
+    const signMessageResult = await protocolRequestHandler('sign_messages', {
+        addresses: [address],
+        payloads: [siwsMessage]
     });
+    const signedPayload = toUint8Array(signMessageResult.signed_payloads[0]);
+    const signedMessage = fromUint8Array$1(signedPayload.slice(0, signedPayload.length - 64));
+    const signature = fromUint8Array$1(signedPayload.slice(signedPayload.length - 64));
+    const signInResult = {
+        address: address,
+        // Workaround: some wallets have been observed to only reply with the message signature.
+        // This is non-compliant with the spec, but in the interest of maximizing compatibility,
+        // detect this case and reuse the original message.
+        signed_message: signedMessage.length == 0 ? siwsMessage : signedMessage,
+        signature
+    };
+    return signInResult;
 }
 
 const SEQUENCE_NUMBER_BYTES = 4;
@@ -301,28 +283,24 @@ function createSequenceNumberVector(sequenceNumber) {
 
 const INITIALIZATION_VECTOR_BYTES = 12;
 const ENCODED_PUBLIC_KEY_LENGTH_BYTES = 65;
-function encryptMessage(plaintext, sequenceNumber, sharedSecret) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const sequenceNumberVector = createSequenceNumberVector(sequenceNumber);
-        const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
-        crypto.getRandomValues(initializationVector);
-        const ciphertext = yield crypto.subtle.encrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, new TextEncoder().encode(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;
-    });
+async function encryptMessage(plaintext, sequenceNumber, sharedSecret) {
+    const sequenceNumberVector = createSequenceNumberVector(sequenceNumber);
+    const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
+    crypto.getRandomValues(initializationVector);
+    const ciphertext = await crypto.subtle.encrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, new TextEncoder().encode(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 decryptMessage(message, sharedSecret) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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);
-        return plaintext;
-    });
+async function decryptMessage(message, sharedSecret) {
+    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 = await crypto.subtle.decrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, ciphertext);
+    const plaintext = getUtf8Decoder().decode(plaintextBuffer);
+    return plaintext;
 }
 function getAlgorithmParams(sequenceNumber, initializationVector) {
     return {
@@ -340,22 +318,18 @@ function getUtf8Decoder() {
     return _utf8Decoder;
 }
 
-function generateAssociationKeypair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield crypto.subtle.generateKey({
-            name: 'ECDSA',
-            namedCurve: 'P-256',
-        }, false /* extractable */, ['sign'] /* keyUsages */);
-    });
+async function generateAssociationKeypair() {
+    return await crypto.subtle.generateKey({
+        name: 'ECDSA',
+        namedCurve: 'P-256',
+    }, false /* extractable */, ['sign'] /* keyUsages */);
 }
 
-function generateECDHKeypair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield crypto.subtle.generateKey({
-            name: 'ECDH',
-            namedCurve: 'P-256',
-        }, false /* extractable */, ['deriveKey', 'deriveBits'] /* keyUsages */);
-    });
+async function generateECDHKeypair() {
+    return await crypto.subtle.generateKey({
+        name: 'ECDH',
+        namedCurve: 'P-256',
+    }, false /* extractable */, ['deriveKey', 'deriveBits'] /* keyUsages */);
 }
 
 // https://stackoverflow.com/a/9458996/802047
@@ -401,12 +375,12 @@ function getIntentURL(methodPathname, intentUrlBase) {
         try {
             baseUrl = new URL(intentUrlBase);
         }
-        catch (_a) { } // eslint-disable-line no-empty
-        if ((baseUrl === null || baseUrl === void 0 ? void 0 : baseUrl.protocol) !== 'https:') {
+        catch { } // eslint-disable-line no-empty
+        if (baseUrl?.protocol !== 'https:') {
             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}:/`));
+    baseUrl ||= new URL(`${INTENT_NAME}:/`);
     const pathname = methodPathname.startsWith('/')
         ? // Method is an absolute path. Replace it wholesale.
             methodPathname
@@ -414,94 +388,82 @@ function getIntentURL(methodPathname, intentUrlBase) {
             [...getPathParts(baseUrl.pathname), ...getPathParts(methodPathname)].join('/');
     return new URL(pathname, baseUrl);
 }
-function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase, protocolVersions = ['v1']) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const associationPort = assertAssociationPort(putativePort);
-        const exportedKey = yield crypto.subtle.exportKey('raw', associationPublicKey);
-        const encodedKey = arrayBufferToBase64String(exportedKey);
-        const url = getIntentURL('v1/associate/local', associationURLBase);
-        url.searchParams.set('association', getStringWithURLUnsafeCharactersReplaced(encodedKey));
-        url.searchParams.set('port', `${associationPort}`);
-        protocolVersions.forEach((version) => {
-            url.searchParams.set('v', version);
-        });
-        return url;
+async function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase, protocolVersions = ['v1']) {
+    const associationPort = assertAssociationPort(putativePort);
+    const exportedKey = await crypto.subtle.exportKey('raw', associationPublicKey);
+    const encodedKey = arrayBufferToBase64String(exportedKey);
+    const url = getIntentURL('v1/associate/local', associationURLBase);
+    url.searchParams.set('association', getStringWithURLUnsafeCharactersReplaced(encodedKey));
+    url.searchParams.set('port', `${associationPort}`);
+    protocolVersions.forEach((version) => {
+        url.searchParams.set('v', version);
     });
+    return url;
 }
-function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, reflectorId, associationURLBase, protocolVersions = ['v1']) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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', `${fromUint8Array$1(reflectorId, true)}`);
-        protocolVersions.forEach((version) => {
-            url.searchParams.set('v', version);
-        });
-        return url;
+async function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, reflectorId, associationURLBase, protocolVersions = ['v1']) {
+    const exportedKey = await 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', `${fromUint8Array$1(reflectorId, true)}`);
+    protocolVersions.forEach((version) => {
+        url.searchParams.set('v', version);
     });
+    return url;
 }
 
-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);
-    });
+async function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+    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;
-    });
+async function decryptJsonRpcMessage(message, sharedSecret) {
+    const plaintext = await 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.
+async 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;
-    });
+    const [associationPublicKeyBuffer, walletPublicKey] = await 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 = await crypto.subtle.deriveBits({ name: 'ECDH', public: walletPublicKey }, ecdhPrivateKey, 256);
+    const ecdhSecretKey = await crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false /* extractable */, ['deriveKey'] /* keyUsages */);
+    const aesKeyMaterialVal = await 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}`);
-            }
+async function parseSessionProps(message, sharedSecret) {
+    const plaintext = await 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
-        });
+    }
+    return ({
+        protocol_version: protocolVersion
     });
 }
 
@@ -546,47 +508,43 @@ function launchUrlThroughHiddenFrame(url) {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     _frame.contentWindow.location.href = url.toString();
 }
-function launchAssociation(associationUrl) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (associationUrl.protocol === 'https:') {
-            // The association URL is an Android 'App Link' or iOS 'Universal Link'.
-            // These are regular web URLs that are designed to launch an app if it
-            // is installed or load the actual target webpage if not.
-            window.location.assign(associationUrl);
-        }
-        else {
-            // The association URL has a custom protocol (eg. `solana-wallet:`)
-            try {
-                const browser = getBrowser();
-                switch (browser) {
-                    case Browser.Firefox:
-                        // If a custom protocol is not supported in Firefox, it throws.
-                        launchUrlThroughHiddenFrame(associationUrl);
-                        // If we reached this line, it's supported.
-                        break;
-                    case Browser.Other: {
-                        const detectionPromise = getDetectionPromise();
-                        window.location.assign(associationUrl);
-                        yield detectionPromise;
-                        break;
-                    }
-                    default:
-                        assertUnreachable(browser);
+async function launchAssociation(associationUrl) {
+    if (associationUrl.protocol === 'https:') {
+        // The association URL is an Android 'App Link' or iOS 'Universal Link'.
+        // These are regular web URLs that are designed to launch an app if it
+        // is installed or load the actual target webpage if not.
+        window.location.assign(associationUrl);
+    }
+    else {
+        // The association URL has a custom protocol (eg. `solana-wallet:`)
+        try {
+            const browser = getBrowser();
+            switch (browser) {
+                case Browser.Firefox:
+                    // If a custom protocol is not supported in Firefox, it throws.
+                    launchUrlThroughHiddenFrame(associationUrl);
+                    // If we reached this line, it's supported.
+                    break;
+                case Browser.Other: {
+                    const detectionPromise = getDetectionPromise();
+                    window.location.assign(associationUrl);
+                    await detectionPromise;
+                    break;
                 }
-            }
-            catch (e) {
-                throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND, 'Found no installed wallet that supports the mobile wallet protocol.');
+                default:
+                    assertUnreachable(browser);
             }
         }
-    });
+        catch (e) {
+            throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_WALLET_NOT_FOUND, 'Found no installed wallet that supports the mobile wallet protocol.');
+        }
+    }
 }
-function startSession(associationPublicKey, associationURLBase) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const randomAssociationPort = getRandomAssociationPort();
-        const associationUrl = yield getAssociateAndroidIntentURL(associationPublicKey, randomAssociationPort, associationURLBase);
-        yield launchAssociation(associationUrl);
-        return randomAssociationPort;
-    });
+async function startSession(associationPublicKey, associationURLBase) {
+    const randomAssociationPort = getRandomAssociationPort();
+    const associationUrl = await getAssociateAndroidIntentURL(associationPublicKey, randomAssociationPort, associationURLBase);
+    await launchAssociation(associationUrl);
+    return randomAssociationPort;
 }
 
 const WEBSOCKET_CONNECTION_CONFIG = {
@@ -615,7 +573,7 @@ function assertSecureEndpointSpecificURI(walletUriBase) {
     try {
         url = new URL(walletUriBase);
     }
-    catch (_a) {
+    catch {
         throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_FORBIDDEN_WALLET_BASE_URL, 'Invalid base URL supplied by wallet');
     }
     if (url.protocol !== 'https:') {
@@ -640,25 +598,38 @@ 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();
-        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 socket;
+async function transact(callback, config) {
+    const { wallet, close } = await startScenario(config);
+    try {
+        return await callback(await wallet);
+    }
+    finally {
+        close();
+    }
+}
+async function startScenario(config) {
+    assertSecureContext();
+    const associationKeypair = await generateAssociationKeypair();
+    const sessionPort = await startSession(associationKeypair.publicKey, 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' };
+    let socket;
+    let sessionEstablished = false;
+    let handleForceClose;
+    return { close: () => {
+            socket.close();
+            handleForceClose();
+        }, wallet: new Promise((resolve, reject) => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const jsonRpcResponsePromises = {};
-            const handleOpen = () => __awaiter(this, void 0, void 0, function* () {
+            const handleOpen = async () => {
                 if (state.__type !== 'connecting') {
                     console.warn('Expected adapter state to be `connecting` at the moment the websocket opens. ' +
                         `Got \`${state.__type}\`.`);
@@ -672,14 +643,14 @@ function transact(callback, config) {
                 // APP_PING was sent by the wallet/websocket server. We must continue to support this behavior 
                 // in case the user is using a wallet that has not updated their walletlib implementation. 
                 const { associationKeypair } = state;
-                const ecdhKeypair = yield generateECDHKeypair();
-                socket.send(yield createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
+                const ecdhKeypair = await generateECDHKeypair();
+                socket.send(await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
                 state = {
                     __type: 'hello_req_sent',
                     associationPublicKey: associationKeypair.publicKey,
                     ecdhPrivateKey: ecdhKeypair.privateKey,
                 };
-            });
+            };
             const handleClose = (evt) => {
                 if (evt.wasClean) {
                     state = { __type: 'disconnected' };
@@ -689,28 +660,28 @@ function transact(callback, config) {
                 }
                 disposeSocket();
             };
-            const handleError = (_evt) => __awaiter(this, void 0, void 0, function* () {
+            const handleError = async (_evt) => {
                 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) => {
+                    await new Promise((resolve) => {
                         const retryDelayMs = getNextRetryDelayMs();
                         retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
                     });
                     attemptSocketConnection();
                 }
-            });
-            const handleMessage = (evt) => __awaiter(this, void 0, void 0, function* () {
-                const responseBuffer = yield evt.data.arrayBuffer();
+            };
+            const handleMessage = async (evt) => {
+                const responseBuffer = await evt.data.arrayBuffer();
                 switch (state.__type) {
                     case 'connecting':
                         if (responseBuffer.byteLength !== 0) {
                             throw new Error('Encountered unexpected message while connecting');
                         }
-                        const ecdhKeypair = yield generateECDHKeypair();
-                        socket.send(yield createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
+                        const ecdhKeypair = await generateECDHKeypair();
+                        socket.send(await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
                         state = {
                             __type: 'hello_req_sent',
                             associationPublicKey: associationKeypair.publicKey,
@@ -725,7 +696,7 @@ function transact(callback, config) {
                                 throw new Error('Encrypted message has invalid sequence number');
                             }
                             lastKnownInboundSequenceNumber = sequenceNumber;
-                            const jsonRpcMessage = yield decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
+                            const jsonRpcMessage = await decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
                             const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
                             delete jsonRpcResponsePromises[jsonRpcMessage.id];
                             responsePromise.resolve(jsonRpcMessage.result);
@@ -744,8 +715,8 @@ function transact(callback, config) {
                     case 'hello_req_sent': {
                         // if we receive an APP_PING message (empty message), resend the HELLO_REQ (see above)
                         if (responseBuffer.byteLength === 0) {
-                            const ecdhKeypair = yield generateECDHKeypair();
-                            socket.send(yield createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
+                            const ecdhKeypair = await generateECDHKeypair();
+                            socket.send(await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey));
                             state = {
                                 __type: 'hello_req_sent',
                                 associationPublicKey: associationKeypair.publicKey,
@@ -753,10 +724,10 @@ function transact(callback, config) {
                             };
                             break;
                         }
-                        const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
+                        const sharedSecret = await parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
                         const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
                         const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
-                            ? yield (() => __awaiter(this, void 0, void 0, function* () {
+                            ? await (async () => {
                                 const sequenceNumberVector = sessionPropertiesBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
                                 const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
                                 if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
@@ -764,15 +735,15 @@ function transact(callback, config) {
                                 }
                                 lastKnownInboundSequenceNumber = sequenceNumber;
                                 return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
-                            }))() : { protocol_version: 'legacy' };
+                            })() : { protocol_version: 'legacy' };
                         state = { __type: 'connected', sharedSecret, sessionProperties };
-                        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, (method, params) => __awaiter(this, void 0, void 0, function* () {
+                        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, async (method, params) => {
                             const id = nextJsonRpcMessageId++;
-                            socket.send(yield encryptJsonRpcMessage({
+                            socket.send(await encryptJsonRpcMessage({
                                 id,
                                 jsonrpc: '2.0',
                                 method,
-                                params: params !== null && params !== void 0 ? params : {},
+                                params: params ?? {},
                             }, sharedSecret));
                             return new Promise((resolve, reject) => {
                                 jsonRpcResponsePromises[id] = {
@@ -798,21 +769,25 @@ function transact(callback, config) {
                                     reject,
                                 };
                             });
-                        }));
+                        });
+                        sessionEstablished = true;
                         try {
-                            resolve(yield callback(wallet));
+                            resolve(wallet);
                         }
                         catch (e) {
                             reject(e);
                         }
-                        finally {
-                            disposeSocket();
-                            socket.close();
-                        }
                         break;
                     }
                 }
-            });
+            };
+            handleForceClose = () => {
+                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') }));
+                }
+            };
             let disposeSocket;
             let retryWaitTimeoutId;
             const attemptSocketConnection = () => {
@@ -837,244 +812,241 @@ function transact(callback, config) {
                 };
             };
             attemptSocketConnection();
-        });
-    });
+        }) };
 }
-function startRemoteScenario(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        assertSecureContext();
-        const associationKeypair = yield generateAssociationKeypair();
-        const websocketURL = `wss://${config === null || config === void 0 ? void 0 : config.remoteHostAuthority}/reflect`;
-        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 encoding;
-        let state = { __type: 'disconnected' };
-        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;
+async function startRemoteScenario(config) {
+    assertSecureContext();
+    const associationKeypair = await generateAssociationKeypair();
+    const websocketURL = `wss://${config?.remoteHostAuthority}/reflect`;
+    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 encoding;
+    let state = { __type: 'disconnected' };
+    let socket;
+    let disposeSocket;
+    let decodeBytes = async (evt) => {
+        if (encoding == 'base64') { // base64 encoding
+            const message = await evt.data;
+            return toUint8Array(message).buffer;
+        }
+        else {
+            return await 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 = await new Promise((resolve, reject) => {
+        const handleOpen = async () => {
+            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 {
-                return yield evt.data.arrayBuffer();
+                encoding = 'binary';
             }
-        });
-        // 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.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 = async (_evt) => {
+            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 {
+                await new Promise((resolve) => {
+                    const retryDelayMs = getNextRetryDelayMs();
+                    retryWaitTimeoutId = window.setTimeout(resolve, retryDelayMs);
+                });
+                attemptSocketConnection();
+            }
+        };
+        const handleReflectorIdMessage = async (evt) => {
+            const responseBuffer = await decodeBytes(evt);
+            if (state.__type === 'connecting') {
+                if (responseBuffer.byteLength == 0) {
+                    throw new Error('Encountered unexpected message while connecting');
                 }
-                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 reflectorId = getReflectorIdFromByteArray(responseBuffer);
+                state = {
+                    __type: 'reflector_id_received',
+                    reflectorId: reflectorId
                 };
+                const associationUrl = await getRemoteAssociateAndroidIntentURL(associationKeypair.publicKey, config.remoteHostAuthority, reflectorId, 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);
             };
-            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 decodeBytes(evt);
-                    switch (state.__type) {
-                        case 'reflector_id_received':
-                            if (responseBuffer.byteLength !== 0) {
-                                throw new Error('Encountered unexpected message while awaiting reflection');
+        };
+        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 = async (evt) => {
+                const responseBuffer = await decodeBytes(evt);
+                switch (state.__type) {
+                    case 'reflector_id_received':
+                        if (responseBuffer.byteLength !== 0) {
+                            throw new Error('Encountered unexpected message while awaiting reflection');
+                        }
+                        const ecdhKeypair = await generateECDHKeypair();
+                        const binaryMsg = await createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey);
+                        if (encoding == 'base64') {
+                            socket.send(fromUint8Array$1(binaryMsg));
+                        }
+                        else {
+                            socket.send(binaryMsg);
+                        }
+                        state = {
+                            __type: 'hello_req_sent',
+                            associationPublicKey: associationKeypair.publicKey,
+                            ecdhPrivateKey: ecdhKeypair.privateKey,
+                        };
+                        break;
+                    case 'connected':
+                        try {
+                            const sequenceNumberVector = responseBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
+                            const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
+                            if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
+                                throw new Error('Encrypted message has invalid sequence number');
                             }
-                            const ecdhKeypair = yield generateECDHKeypair();
-                            const binaryMsg = yield createHelloReq(ecdhKeypair.publicKey, associationKeypair.privateKey);
-                            if (encoding == 'base64') {
-                                socket.send(fromUint8Array$1(binaryMsg));
+                            lastKnownInboundSequenceNumber = sequenceNumber;
+                            const jsonRpcMessage = await decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
+                            const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
+                            delete jsonRpcResponsePromises[jsonRpcMessage.id];
+                            responsePromise.resolve(jsonRpcMessage.result);
+                        }
+                        catch (e) {
+                            if (e instanceof SolanaMobileWalletAdapterProtocolError) {
+                                const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                delete jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                responsePromise.reject(e);
                             }
                             else {
-                                socket.send(binaryMsg);
+                                throw e;
                             }
-                            state = {
-                                __type: 'hello_req_sent',
-                                associationPublicKey: associationKeypair.publicKey,
-                                ecdhPrivateKey: ecdhKeypair.privateKey,
-                            };
-                            break;
-                        case 'connected':
-                            try {
-                                const sequenceNumberVector = responseBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
+                        }
+                        break;
+                    case 'hello_req_sent': {
+                        const sharedSecret = await parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
+                        const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
+                        const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
+                            ? await (async () => {
+                                const sequenceNumberVector = sessionPropertiesBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
                                 const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
                                 if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
                                     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);
+                                return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
+                            })() : { protocol_version: 'legacy' };
+                        state = { __type: 'connected', sharedSecret, sessionProperties };
+                        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, async (method, params) => {
+                            const id = nextJsonRpcMessageId++;
+                            const binaryMsg = await encryptJsonRpcMessage({
+                                id,
+                                jsonrpc: '2.0',
+                                method,
+                                params: params ?? {},
+                            }, sharedSecret);
+                            if (encoding == 'base64') {
+                                socket.send(fromUint8Array$1(binaryMsg));
                             }
-                            catch (e) {
-                                if (e instanceof SolanaMobileWalletAdapterProtocolError) {
-                                    const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
-                                    delete jsonRpcResponsePromises[e.jsonRpcMessageId];
-                                    responsePromise.reject(e);
-                                }
-                                else {
-                                    throw e;
-                                }
+                            else {
+                                socket.send(binaryMsg);
                             }
-                            break;
-                        case 'hello_req_sent': {
-                            const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
-                            const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
-                            const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
-                                ? yield (() => __awaiter(this, void 0, void 0, function* () {
-                                    const sequenceNumberVector = sessionPropertiesBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
-                                    const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
-                                    if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
-                                        throw new Error('Encrypted message has invalid sequence number');
-                                    }
-                                    lastKnownInboundSequenceNumber = sequenceNumber;
-                                    return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
-                                }))() : { protocol_version: 'legacy' };
-                            state = { __type: 'connected', sharedSecret, sessionProperties };
-                            const wallet = createMobileWalletProxy(sessionProperties.protocol_version, (method, params) => __awaiter(this, void 0, void 0, function* () {
-                                const id = nextJsonRpcMessageId++;
-                                const binaryMsg = yield encryptJsonRpcMessage({
-                                    id,
-                                    jsonrpc: '2.0',
-                                    method,
-                                    params: params !== null && params !== void 0 ? params : {},
-                                }, sharedSecret);
-                                if (encoding == 'base64') {
-                                    socket.send(fromUint8Array$1(binaryMsg));
-                                }
-                                else {
-                                    socket.send(binaryMsg);
-                                }
-                                return new Promise((resolve, reject) => {
-                                    jsonRpcResponsePromises[id] = {
-                                        resolve(result) {
-                                            switch (method) {
-                                                case 'authorize':
-                                                case 'reauthorize': {
-                                                    const { wallet_uri_base } = result;
-                                                    if (wallet_uri_base != null) {
-                                                        try {
-                                                            assertSecureEndpointSpecificURI(wallet_uri_base);
-                                                        }
-                                                        catch (e) {
-                                                            reject(e);
-                                                            return;
-                                                        }
+                            return new Promise((resolve, reject) => {
+                                jsonRpcResponsePromises[id] = {
+                                    resolve(result) {
+                                        switch (method) {
+                                            case 'authorize':
+                                            case 'reauthorize': {
+                                                const { wallet_uri_base } = result;
+                                                if (wallet_uri_base != null) {
+                                                    try {
+                                                        assertSecureEndpointSpecificURI(wallet_uri_base);
+                                                    }
+                                                    catch (e) {
+                                                        reject(e);
+                                                        return;
                                                     }
-                                                    break;
                                                 }
+                                                break;
                                             }
-                                            resolve(result);
-                                        },
-                                        reject,
-                                    };
-                                });
-                            }));
-                            sessionEstablished = true;
-                            try {
-                                resolve(wallet);
-                            }
-                            catch (e) {
-                                reject(e);
-                            }
-                            break;
+                                        }
+                                        resolve(result);
+                                    },
+                                    reject,
+                                };
+                            });
+                        });
+                        sessionEstablished = true;
+                        try {
+                            resolve(wallet);
                         }
+                        catch (e) {
+                            reject(e);
+                        }
+                        break;
                     }
-                });
-                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.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') }));
+                }
+            };
+        }) };
 }
 
-export { SolanaCloneAuthorization, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaSignInWithSolana, SolanaSignTransactions, startRemoteScenario, transact };
+export { SolanaCloneAuthorization, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaSignInWithSolana, SolanaSignTransactions, startRemoteScenario, startScenario, transact };