@solana-mobile/mobile-wallet-adapter-protocol 2.1.3 → 2.1.5

package/lib/esm/index.browser.js

@@ -3,6 +3,7 @@ import { createSignInMessageText } from '@solana/wallet-standard-util';
 // Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
 const SolanaMobileWalletAdapterErrorCode = {
     ERROR_ASSOCIATION_PORT_OUT_OF_RANGE: 'ERROR_ASSOCIATION_PORT_OUT_OF_RANGE',
+    ERROR_REFLECTOR_ID_OUT_OF_RANGE: 'ERROR_REFLECTOR_ID_OUT_OF_RANGE',
     ERROR_FORBIDDEN_WALLET_BASE_URL: 'ERROR_FORBIDDEN_WALLET_BASE_URL',
     ERROR_SECURE_CONTEXT_REQUIRED: 'ERROR_SECURE_CONTEXT_REQUIRED',
     ERROR_SESSION_CLOSED: 'ERROR_SESSION_CLOSED',
@@ -406,6 +407,24 @@ 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
@@ -447,6 +466,21 @@ function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associ
         return url;
     });
 }
+function getRemoteAssociateAndroidIntentURL(associationPublicKey, hostAuthority, putativeId, 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}`);
+        protocolVersions.forEach((version) => {
+            url.searchParams.set('v', version);
+        });
+        return url;
+    });
+}
 
 // Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
 const Browser = {
@@ -489,10 +523,8 @@ function launchUrlThroughHiddenFrame(url) {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     _frame.contentWindow.location.href = url.toString();
 }
-function startSession(associationPublicKey, associationURLBase) {
+function launchAssociation(associationUrl) {
     return __awaiter(this, void 0, void 0, function* () {
-        const randomAssociationPort = getRandomAssociationPort();
-        const associationUrl = yield getAssociateAndroidIntentURL(associationPublicKey, randomAssociationPort, associationURLBase);
         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
@@ -523,9 +555,23 @@ function startSession(associationPublicKey, associationURLBase) {
                 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;
     });
 }
+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 = {
     /**
@@ -587,8 +633,14 @@ function transact(callback, config) {
                         `Got \`${state.__type}\`.`);
                     return;
                 }
-                const { associationKeypair } = state;
                 socket.removeEventListener('open', handleOpen);
+                // previous versions of this library and walletlib incorrectly implemented the MWA session 
+                // establishment protocol for local connections. The dapp is supposed to wait for the 
+                // APP_PING message before sending the HELLO_REQ. Instead, the dapp was sending the HELLO_REQ 
+                // immediately upon connection to the websocket server regardless of wether or not an 
+                // 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));
                 state = {
@@ -609,7 +661,7 @@ function transact(callback, config) {
             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 on port ${sessionPort}.`));
+                    reject(new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_SESSION_TIMEOUT, `Failed to connect to the wallet websocket at ${websocketURL}.`));
                 }
                 else {
                     yield new Promise((resolve) => {
@@ -622,6 +674,18 @@ function transact(callback, config) {
             const handleMessage = (evt) => __awaiter(this, void 0, void 0, function* () {
                 const responseBuffer = yield 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));
+                        state = {
+                            __type: 'hello_req_sent',
+                            associationPublicKey: associationKeypair.publicKey,
+                            ecdhPrivateKey: ecdhKeypair.privateKey,
+                        };
+                        break;
                     case 'connected':
                         try {
                             const sequenceNumberVector = responseBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
@@ -647,6 +711,17 @@ function transact(callback, config) {
                         }
                         break;
                     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));
+                            state = {
+                                __type: 'hello_req_sent',
+                                associationPublicKey: associationKeypair.publicKey,
+                                ecdhPrivateKey: ecdhKeypair.privateKey,
+                            };
+                            break;
+                        }
                         const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
                         const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
                         const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
@@ -734,5 +809,190 @@ function transact(callback, config) {
         });
     });
 }
+function transactRemote(callback, 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}`;
+        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 { 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 }));
+                    }
+                    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 handleMessage = (evt) => __awaiter(this, void 0, void 0, function* () {
+                    const responseBuffer = yield 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));
+                            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');
+                                }
+                                lastKnownInboundSequenceNumber = sequenceNumber;
+                                const jsonRpcMessage = yield decryptJsonRpcMessage(responseBuffer, state.sharedSecret);
+                                const responsePromise = jsonRpcResponsePromises[jsonRpcMessage.id];
+                                delete jsonRpcResponsePromises[jsonRpcMessage.id];
+                                responsePromise.resolve(jsonRpcMessage.result);
+                            }
+                            catch (e) {
+                                if (e instanceof SolanaMobileWalletAdapterProtocolError) {
+                                    const responsePromise = jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                    delete jsonRpcResponsePromises[e.jsonRpcMessageId];
+                                    responsePromise.reject(e);
+                                }
+                                else {
+                                    throw e;
+                                }
+                            }
+                            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++;
+                                socket.send(yield encryptJsonRpcMessage({
+                                    id,
+                                    jsonrpc: '2.0',
+                                    method,
+                                    params: params !== null && params !== void 0 ? params : {},
+                                }, sharedSecret));
+                                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;
+                                                }
+                                            }
+                                            resolve(result);
+                                        },
+                                        reject,
+                                    };
+                                });
+                            }));
+                            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];
+                                    },
+                                })));
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                            break;
+                        }
+                    }
+                });
+                let disposeSocket;
+                let retryWaitTimeoutId;
+                const attemptSocketConnection = () => {
+                    if (disposeSocket) {
+                        disposeSocket();
+                    }
+                    state = { __type: 'connecting', associationKeypair };
+                    if (connectionStartTime === undefined) {
+                        connectionStartTime = Date.now();
+                    }
+                    socket = new WebSocket(websocketURL, [WEBSOCKET_PROTOCOL]);
+                    socket.addEventListener('open', handleOpen);
+                    socket.addEventListener('close', handleClose);
+                    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();
+            }) };
+    });
+}
 
-export { SolanaCloneAuthorization, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaSignInWithSolana, SolanaSignTransactions, transact };
+export { SolanaCloneAuthorization, SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode, SolanaMobileWalletAdapterProtocolError, SolanaMobileWalletAdapterProtocolErrorCode, SolanaSignInWithSolana, SolanaSignTransactions, transact, transactRemote };