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

package/src/jsonRpcMessage.ts

@@ -1,81 +1,38 @@
-import createSequenceNumberVector, { SEQUENCE_NUMBER_BYTES } from './createSequenceNumberVector.js';
-import { SolanaMobileWalletAdapterProtocolError } from './errors.js';
-import { SharedSecret } from './parseHelloRsp.js';
-
-const INITIALIZATION_VECTOR_BYTES = 12;
-
-interface JSONRPCRequest<TParams> {
-    id: number;
-    jsonrpc: '2.0';
-    method: string;
-    params: TParams;
-}
-
-type JSONRPCResponse<TMessage> = {
-    id: number;
-    jsonrpc: '2.0';
-    result: TMessage;
-};
-
-export async function encryptJsonRpcMessage<TParams>(
-    jsonRpcMessage: JSONRPCRequest<TParams>,
-    sharedSecret: SharedSecret,
-) {
-    const plaintext = JSON.stringify(jsonRpcMessage);
-    const sequenceNumberVector = createSequenceNumberVector(jsonRpcMessage.id);
-    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;
-}
-
-export async function decryptJsonRpcMessage<TMessage>(message: ArrayBuffer, sharedSecret: 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);
-    const jsonRpcMessage = JSON.parse(plaintext);
-    if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
-        throw new SolanaMobileWalletAdapterProtocolError<typeof jsonRpcMessage.error.code>(
-            jsonRpcMessage.id,
-            jsonRpcMessage.error.code,
-            jsonRpcMessage.error.message,
-        );
-    }
-    return jsonRpcMessage as JSONRPCResponse<TMessage>;
-}
-
-function getAlgorithmParams(sequenceNumber: ArrayBuffer, initializationVector: ArrayBuffer) {
-    return {
-        additionalData: sequenceNumber,
-        iv: initializationVector,
-        name: 'AES-GCM',
-        tagLength: 128, // 16 byte tag => 128 bits
-    };
-}
-
-let _utf8Decoder: TextDecoder | undefined;
-function getUtf8Decoder() {
-    if (_utf8Decoder === undefined) {
-        _utf8Decoder = new TextDecoder('utf-8');
-    }
-    return _utf8Decoder;
-}
+import { decryptMessage, encryptMessage } from './encryptedMessage.js';
+import { SolanaMobileWalletAdapterProtocolError } from './errors.js';
+import { SharedSecret } from './parseHelloRsp.js';
+
+interface JSONRPCRequest<TParams> {
+    id: number;
+    jsonrpc: '2.0';
+    method: string;
+    params: TParams;
+}
+
+type JSONRPCResponse<TMessage> = {
+    id: number;
+    jsonrpc: '2.0';
+    result: TMessage;
+};
+
+export async function encryptJsonRpcMessage<TParams>(
+    jsonRpcMessage: JSONRPCRequest<TParams>,
+    sharedSecret: SharedSecret,
+) {
+    const plaintext = JSON.stringify(jsonRpcMessage);
+    const sequenceNumber = jsonRpcMessage.id;
+    return encryptMessage(plaintext, sequenceNumber, sharedSecret);
+}
+
+export async function decryptJsonRpcMessage<TMessage>(message: ArrayBuffer, sharedSecret: SharedSecret) {
+    const plaintext = await decryptMessage(message, sharedSecret);
+    const jsonRpcMessage = JSON.parse(plaintext);
+    if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
+        throw new SolanaMobileWalletAdapterProtocolError<typeof jsonRpcMessage.error.code>(
+            jsonRpcMessage.id,
+            jsonRpcMessage.error.code,
+            jsonRpcMessage.error.message,
+        );
+    }
+    return jsonRpcMessage as JSONRPCResponse<TMessage>;
+}

package/src/parseHelloRsp.ts

@@ -1,44 +1,46 @@
-/**
- * A secret agreed upon by the app and the wallet. Used as
- * a symmetric key to encrypt and decrypt messages over an
- * unsecured channel.
- */
-export type SharedSecret = CryptoKey;
-
-export default async function parseHelloRsp(
-    payloadBuffer: ArrayBuffer, // The X9.62-encoded wallet endpoint ephemeral ECDH public keypoint.
-    associationPublicKey: CryptoKey,
-    ecdhPrivateKey: CryptoKey,
-): Promise<SharedSecret> {
-    const [associationPublicKeyBuffer, walletPublicKey] = await Promise.all([
-        crypto.subtle.exportKey('raw', associationPublicKey),
-        crypto.subtle.importKey(
-            'raw',
-            payloadBuffer,
-            { 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 as SharedSecret;
-}
+import { ENCODED_PUBLIC_KEY_LENGTH_BYTES } from "./encryptedMessage";
+
+/**
+ * A secret agreed upon by the app and the wallet. Used as
+ * a symmetric key to encrypt and decrypt messages over an
+ * unsecured channel.
+ */
+export type SharedSecret = CryptoKey;
+
+export default async function parseHelloRsp(
+    payloadBuffer: ArrayBuffer, // The X9.62-encoded wallet endpoint ephemeral ECDH public keypoint.
+    associationPublicKey: CryptoKey,
+    ecdhPrivateKey: CryptoKey,
+): Promise<SharedSecret> {
+    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 as SharedSecret;
+}

package/src/parseSessionProps.ts

@@ -0,0 +1,33 @@
+import { decryptMessage } from "./encryptedMessage";
+import { SolanaMobileWalletAdapterError, SolanaMobileWalletAdapterErrorCode } from "./errors";
+import { SharedSecret } from "./parseHelloRsp";
+import { ProtocolVersion, SessionProperties } from "./types";
+
+export default async function parseSessionProps(
+    message: ArrayBuffer, 
+    sharedSecret: SharedSecret
+): Promise<SessionProperties> {
+    const plaintext = await decryptMessage(message, sharedSecret);
+    const jsonProperties = JSON.parse(plaintext);
+    let protocolVersion: 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 <SessionProperties>({
+        protocol_version: protocolVersion
+    })
+}