@solana-mobile/mobile-wallet-adapter-protocol 2.0.0 → 2.0.2

package/lib/cjs/index.js

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var walletStandardUtil = require('@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',
@@ -10,6 +12,7 @@ const SolanaMobileWalletAdapterErrorCode = {
     ERROR_SESSION_CLOSED: 'ERROR_SESSION_CLOSED',
     ERROR_SESSION_TIMEOUT: 'ERROR_SESSION_TIMEOUT',
     ERROR_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
+    ERROR_INVALID_PROTOCOL_VERSION: 'ERROR_INVALID_PROTOCOL_VERSION',
 };
 class SolanaMobileWalletAdapterError extends Error {
     constructor(...args) {
@@ -77,6 +80,175 @@ function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
     });
 }
 
+function encode(input) {
+    return window.btoa(input);
+}
+
+function createSIWSMessage(payload) {
+    return walletStandardUtil.createSignInMessageText(payload);
+}
+function createSIWSMessageBase64(payload) {
+    return encode(createSIWSMessage(payload));
+}
+
+// optional features
+const SolanaSignTransactions = 'solana:signTransactions';
+const SolanaCloneAuthorization = 'solana:cloneAuthorization';
+const SolanaSignInWithSolana = 'solana:signInWithSolana';
+
+/**
+ * Creates a {@link MobileWallet} proxy that handles backwards compatibility and API to RPC conversion.
+ *
+ * @param protocolVersion the protocol version in use for this session/request
+ * @param protocolRequestHandler callback function that handles sending the RPC request to the wallet endpoint.
+ * @returns a {@link MobileWallet} proxy
+ */
+function createMobileWalletProxy(protocolVersion, protocolRequestHandler) {
+    return new Proxy({}, {
+        get(target, p) {
+            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);
+                    });
+                };
+            }
+            return target[p];
+        },
+        defineProperty() {
+            return false;
+        },
+        deleteProperty() {
+            return false;
+        },
+    });
+}
+/**
+ * Handles all {@link MobileWallet} API requests and determines the correct MWA RPC method and params to call.
+ * This handles backwards compatibility, based on the provided @protocolVersion.
+ *
+ * @param methodName the name of {@link MobileWallet} method that was called
+ * @param methodParams the parameters that were passed to the method
+ * @param protocolVersion the protocol version in use for this session/request
+ * @returns the RPC request method and params that should be sent to the wallet endpoint
+ */
+function handleMobileWalletRequest(methodName, methodParams, protocolVersion) {
+    let params = methodParams;
+    let method = methodName
+        .toString()
+        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+        .toLowerCase();
+    switch (methodName) {
+        case 'authorize': {
+            let { chain } = params;
+            if (protocolVersion === 'legacy') {
+                switch (chain) {
+                    case 'solana:testnet': {
+                        chain = 'testnet';
+                        break;
+                    }
+                    case 'solana:devnet': {
+                        chain = 'devnet';
+                        break;
+                    }
+                    case 'solana:mainnet': {
+                        chain = 'mainnet-beta';
+                        break;
+                    }
+                    default: {
+                        chain = params.cluster;
+                    }
+                }
+                params.cluster = chain;
+            }
+            else {
+                switch (chain) {
+                    case 'testnet':
+                    case 'devnet': {
+                        chain = `solana:${chain}`;
+                        break;
+                    }
+                    case 'mainnet-beta': {
+                        chain = 'solana:mainnet';
+                        break;
+                    }
+                }
+                params.chain = chain;
+            }
+        }
+        case 'reauthorize': {
+            const { auth_token, identity } = params;
+            if (auth_token) {
+                switch (protocolVersion) {
+                    case 'legacy': {
+                        method = 'reauthorize';
+                        params = { auth_token: auth_token, identity: identity };
+                        break;
+                    }
+                    default: {
+                        method = 'authorize';
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+    }
+    return { method, params };
+}
+/**
+ * Handles all {@link MobileWallet} API responses and modifies the response for backwards compatibility, if needed
+ *
+ * @param method the {@link MobileWallet} method that was called
+ * @param response the original response that was returned by the method call
+ * @param protocolVersion the protocol version in use for this session/request
+ * @returns the possibly modified response
+ */
+function handleMobileWalletResponse(method, response, protocolVersion) {
+    switch (method) {
+        case 'getCapabilities': {
+            const capabilities = response;
+            switch (protocolVersion) {
+                case 'legacy': {
+                    const features = [SolanaSignTransactions];
+                    if (capabilities.supports_clone_authorization === true) {
+                        features.push(SolanaCloneAuthorization);
+                    }
+                    return Object.assign(Object.assign({}, 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 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 = createSIWSMessageBase64(Object.assign(Object.assign({}, signInPayload), { domain, address }));
+        const signMessageResult = yield protocolRequestHandler('sign_messages', {
+            addresses: [address],
+            payloads: [siwsMessage]
+        });
+        const signInResult = {
+            address: address,
+            signed_message: siwsMessage,
+            signature: signMessageResult.signed_payloads[0].slice(siwsMessage.length)
+        };
+        return signInResult;
+    });
+}
+
 const SEQUENCE_NUMBER_BYTES = 4;
 function createSequenceNumberVector(sequenceNumber) {
     if (sequenceNumber >= 4294967296) {
@@ -88,29 +260,11 @@ function createSequenceNumberVector(sequenceNumber) {
     return new Uint8Array(byteArray);
 }
 
-function generateAssociationKeypair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield 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 */);
-    });
-}
-
 const INITIALIZATION_VECTOR_BYTES = 12;
-function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+const ENCODED_PUBLIC_KEY_LENGTH_BYTES = 65;
+function encryptMessage(plaintext, sequenceNumber, sharedSecret) {
     return __awaiter(this, void 0, void 0, function* () {
-        const plaintext = JSON.stringify(jsonRpcMessage);
-        const sequenceNumberVector = createSequenceNumberVector(jsonRpcMessage.id);
+        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));
@@ -121,18 +275,14 @@ function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
         return response;
     });
 }
-function decryptJsonRpcMessage(message, sharedSecret) {
+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);
-        const jsonRpcMessage = JSON.parse(plaintext);
-        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
-            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
-        }
-        return jsonRpcMessage;
+        return plaintext;
     });
 }
 function getAlgorithmParams(sequenceNumber, initializationVector) {
@@ -151,12 +301,48 @@ 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 */);
+    });
+}
+
+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 */);
+    });
+}
+
+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, { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
+            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 */);
@@ -170,6 +356,31 @@ associationPublicKey, ecdhPrivateKey) {
     });
 }
 
+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
+        });
+    });
+}
+
 function getRandomAssociationPort() {
     return assertAssociationPort(49152 + Math.floor(Math.random() * (65535 - 49152 + 1)));
 }
@@ -226,7 +437,7 @@ function getIntentURL(methodPathname, intentUrlBase) {
             [...getPathParts(baseUrl.pathname), ...getPathParts(methodPathname)].join('/');
     return new URL(pathname, baseUrl);
 }
-function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase) {
+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);
@@ -234,6 +445,9 @@ function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associ
         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;
     });
 }
@@ -438,59 +652,51 @@ function transact(callback, config) {
                         break;
                     case 'hello_req_sent': {
                         const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
-                        state = { __type: 'connected', sharedSecret };
-                        const wallet = new Proxy({}, {
-                            get(target, p) {
-                                if (target[p] == null) {
-                                    const method = p
-                                        .toString()
-                                        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
-                                        .toLowerCase();
-                                    target[p] = function (params) {
-                                        return __awaiter(this, void 0, void 0, function* () {
-                                            const id = nextJsonRpcMessageId++;
-                                            socket.send(yield encryptJsonRpcMessage({
-                                                id,
-                                                jsonrpc: '2.0',
-                                                method,
-                                                params: params !== null && params !== void 0 ? params : {},
-                                            }, sharedSecret));
-                                            return new Promise((resolve, reject) => {
-                                                jsonRpcResponsePromises[id] = {
-                                                    resolve(result) {
-                                                        switch (p) {
-                                                            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,
-                                                };
-                                            });
-                                        });
-                                    };
+                        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');
                                 }
-                                return target[p];
-                            },
-                            defineProperty() {
-                                return false;
-                            },
-                            deleteProperty() {
-                                return false;
-                            },
-                        });
+                                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(wallet));
                         }
@@ -533,8 +739,11 @@ function transact(callback, config) {
     });
 }
 
+exports.SolanaCloneAuthorization = SolanaCloneAuthorization;
 exports.SolanaMobileWalletAdapterError = SolanaMobileWalletAdapterError;
 exports.SolanaMobileWalletAdapterErrorCode = SolanaMobileWalletAdapterErrorCode;
 exports.SolanaMobileWalletAdapterProtocolError = SolanaMobileWalletAdapterProtocolError;
 exports.SolanaMobileWalletAdapterProtocolErrorCode = SolanaMobileWalletAdapterProtocolErrorCode;
+exports.SolanaSignInWithSolana = SolanaSignInWithSolana;
+exports.SolanaSignTransactions = SolanaSignTransactions;
 exports.transact = transact;