zapo-js 0.1.1 → 0.2.0

package/dist/esm/transport/node/helpers.js

@@ -1,15 +1,118 @@
-import { base64ToBytes, TEXT_ENCODER } from '../../util/bytes.js';
+import { randomFillAsync } from '../../crypto/index.js';
+import { base64ToBytesChecked, TEXT_DECODER, TEXT_ENCODER } from '../../util/bytes.js';
+const EMPTY_NODE_CHILDREN = Object.freeze([]);
+const EMPTY_NODE_TAGS = Object.freeze([]);
+const EMPTY_NODE_VALUES = Object.freeze([]);
+const NODE_ID_PREFIX_SEED = new Uint8Array(4);
 export function getNodeChildren(node) {
-    return Array.isArray(node.content) ? node.content : [];
+    return Array.isArray(node.content) ? node.content : EMPTY_NODE_CHILDREN;
 }
 export function findNodeChild(node, tag) {
-    return getNodeChildren(node).find((child) => child.tag === tag);
+    const content = node.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (let i = 0; i < content.length; i++) {
+        if (content[i].tag === tag)
+            return content[i];
+    }
 }
 export function getFirstNodeChild(node) {
     return getNodeChildren(node)[0];
 }
 export function getNodeChildrenByTag(node, tag) {
-    return getNodeChildren(node).filter((child) => child.tag === tag);
+    const content = node.content;
+    if (!Array.isArray(content))
+        return EMPTY_NODE_CHILDREN;
+    let tagged = null;
+    for (let i = 0; i < content.length; i++) {
+        if (content[i].tag !== tag)
+            continue;
+        if (!tagged)
+            tagged = [];
+        tagged.push(content[i]);
+    }
+    return tagged ?? EMPTY_NODE_CHILDREN;
+}
+export function getNodeChildrenByTagFromChildren(node, tag) {
+    let tagged = null;
+    const content = node.content;
+    if (!Array.isArray(content))
+        return EMPTY_NODE_CHILDREN;
+    for (let i = 0; i < content.length; i += 1) {
+        const nested = content[i].content;
+        if (!Array.isArray(nested))
+            continue;
+        for (let j = 0; j < nested.length; j += 1) {
+            if (nested[j].tag !== tag)
+                continue;
+            if (!tagged)
+                tagged = [];
+            tagged.push(nested[j]);
+        }
+    }
+    return tagged ?? EMPTY_NODE_CHILDREN;
+}
+export function getNodeChildrenTags(node) {
+    const content = node.content;
+    if (!Array.isArray(content) || content.length === 0)
+        return EMPTY_NODE_TAGS;
+    const tags = new Array(content.length);
+    for (let i = 0; i < content.length; i += 1) {
+        tags[i] = content[i].tag;
+    }
+    return tags;
+}
+export function getNodeChildrenNonEmptyAttrValuesByTag(node, tag, attr) {
+    let values = null;
+    const children = getNodeChildren(node);
+    for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        if (child.tag !== tag) {
+            continue;
+        }
+        const value = child.attrs[attr];
+        if (!value) {
+            continue;
+        }
+        if (!values) {
+            values = [];
+        }
+        values.push(value);
+    }
+    return values ?? EMPTY_NODE_VALUES;
+}
+export function getNodeChildrenNonEmptyUtf8ByTag(node, tag, field) {
+    let values = null;
+    const children = getNodeChildren(node);
+    for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        if (child.tag !== tag) {
+            continue;
+        }
+        const raw = child.content;
+        if (raw === null || raw === undefined) {
+            continue;
+        }
+        if (raw instanceof Uint8Array && raw.length === 0) {
+            continue;
+        }
+        const value = TEXT_DECODER.decode(decodeNodeContentUtf8OrBytes(raw, field));
+        if (value.length === 0) {
+            continue;
+        }
+        if (!values) {
+            values = [];
+        }
+        values.push(value);
+    }
+    return values ?? EMPTY_NODE_VALUES;
+}
+export function findNodeChildrenByTags(node, tags) {
+    const out = new Array(tags.length);
+    for (let index = 0; index < tags.length; index += 1) {
+        out[index] = findNodeChild(node, tags[index]);
+    }
+    return out;
 }
 export function hasNodeChild(node, tag) {
     return findNodeChild(node, tag) !== undefined;
@@ -28,10 +131,27 @@ export function decodeNodeContentBase64OrBytes(value, field) {
         throw new Error(`missing binary node content for ${field}`);
     }
     if (typeof value === 'string') {
-        return base64ToBytes(value);
+        return base64ToBytesChecked(value, field);
     }
     if (value instanceof Uint8Array) {
         return value;
     }
     throw new Error(`missing binary node content for ${field}`);
 }
+export function formatNodeIdPrefixFromSeed(seed) {
+    const left = ((seed[0] << 8) | seed[1]) >>> 0;
+    const right = ((seed[2] << 8) | seed[3]) >>> 0;
+    return `${left}.${right}-`;
+}
+export async function createNodeIdGenerator() {
+    await randomFillAsync(NODE_ID_PREFIX_SEED);
+    const prefix = formatNodeIdPrefixFromSeed(NODE_ID_PREFIX_SEED);
+    let counter = 0;
+    return {
+        prefix,
+        next() {
+            counter += 1;
+            return `${prefix}${counter}`;
+        }
+    };
+}

package/dist/esm/transport/node/usync.js

@@ -0,0 +1,5 @@
+import { createNodeIdGenerator } from './helpers.js';
+export function createUsyncSidGenerator() {
+    const generatorPromise = createNodeIdGenerator();
+    return async () => (await generatorPromise).next();
+}

package/dist/esm/transport/node/xml.js

@@ -1,23 +1,41 @@
 import { bytesToBase64 } from '../../util/bytes.js';
 const XML_INDENT = '    ';
 function escapeXml(value) {
-    return value
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-function renderAttrs(attrs) {
-    const entries = Object.entries(attrs);
-    if (entries.length === 0) {
-        return '';
+    let out = '';
+    let last = 0;
+    for (let i = 0; i < value.length; i++) {
+        let esc;
+        switch (value.charCodeAt(i)) {
+            case 38:
+                esc = '&amp;';
+                break;
+            case 60:
+                esc = '&lt;';
+                break;
+            case 62:
+                esc = '&gt;';
+                break;
+            case 34:
+                esc = '&quot;';
+                break;
+            case 39:
+                esc = '&apos;';
+                break;
+        }
+        if (esc) {
+            out += value.slice(last, i) + esc;
+            last = i + 1;
+        }
     }
-    return entries.map(([key, value]) => ` ${key}='${escapeXml(value)}'`).join('');
+    return last === 0 ? value : out + value.slice(last);
 }
 function renderNode(node, depth) {
     const indent = XML_INDENT.repeat(depth);
-    const attrs = renderAttrs(node.attrs);
+    const keys = Object.keys(node.attrs);
+    let attrs = '';
+    for (let i = 0; i < keys.length; i++) {
+        attrs += ` ${keys[i]}='${escapeXml(node.attrs[keys[i]])}'`;
+    }
     const content = node.content;
     if (content === undefined) {
         return `${indent}<${node.tag}${attrs}/>`;
@@ -31,7 +49,10 @@ function renderNode(node, depth) {
     if (content.length === 0) {
         return `${indent}<${node.tag}${attrs}/>`;
     }
-    const children = content.map((child) => renderNode(child, depth + 1)).join('\n');
+    let children = renderNode(content[0], depth + 1);
+    for (let i = 1; i < content.length; i++) {
+        children += '\n' + renderNode(content[i], depth + 1);
+    }
     return `${indent}<${node.tag}${attrs}>\n${children}\n${indent}</${node.tag}>`;
 }
 export function formatBinaryNodeAsXml(node) {

package/dist/esm/transport/noise/WaClientPayload.js

@@ -1,7 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { md5Bytes } from '../../crypto/core/primitives.js';
 import { proto } from '../../proto.js';
-import { KEY_TYPE_CURVE25519 } from '../../signal/constants.js';
 import { DEFAULT_VERSION_BASE } from '../noise/constants.js';
 import { intToBytes, toBytesView } from '../../util/bytes.js';
 function parseVersion(versionBase) {
@@ -60,8 +59,8 @@ function resolveDevicePropsPlatformType(deviceBrowser) {
             return proto.DeviceProps.PlatformType.UNKNOWN;
     }
 }
-function defaultUserAgent(versionBase, deviceOsDisplayName) {
-    const { primary, secondary, tertiary } = parseVersion(versionBase);
+function defaultUserAgent(versionBase, deviceOsDisplayName, version) {
+    const { primary, secondary, tertiary } = version ?? parseVersion(versionBase);
     const locale = resolveLocale();
     return {
         platform: proto.ClientPayload.UserAgent.Platform.WEB,
@@ -82,8 +81,8 @@ function defaultUserAgent(versionBase, deviceOsDisplayName) {
         localeCountryIso31661Alpha2: locale.lc
     };
 }
-function defaultDeviceProps(versionBase, config) {
-    const { primary, secondary, tertiary } = parseVersion(versionBase);
+function defaultDeviceProps(versionBase, config, version) {
+    const { primary, secondary, tertiary } = version ?? parseVersion(versionBase);
     return proto.DeviceProps.encode({
         os: config.deviceOsDisplayName ?? process.platform,
         version: {
@@ -105,7 +104,7 @@ function defaultDeviceProps(versionBase, config) {
         }
     }).finish();
 }
-function buildCommonPayload(config) {
+function buildCommonPayload(config, version) {
     const versionBase = config.versionBase ?? DEFAULT_VERSION_BASE;
     const pull = config.pull ?? true;
     return {
@@ -113,7 +112,7 @@ function buildCommonPayload(config) {
         pull,
         connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
         connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: config.userAgent ?? defaultUserAgent(versionBase, config.deviceOsDisplayName),
+        userAgent: config.userAgent ?? defaultUserAgent(versionBase, config.deviceOsDisplayName, version),
         webInfo: config.webInfo ??
             {
                 webSubPlatform: defaultWebSubPlatform()
@@ -142,14 +141,15 @@ export function buildRegistrationPayload(config) {
         throw new Error('registration payload requires a valid signedPreKeyId');
     }
     const versionBase = config.versionBase ?? DEFAULT_VERSION_BASE;
-    const common = buildCommonPayload(config);
+    const version = parseVersion(versionBase);
+    const common = buildCommonPayload(config, version);
     const devicePairingData = {
         buildHash: config.buildHash ? toBytesView(config.buildHash) : md5Bytes(versionBase),
         deviceProps: config.deviceProps
             ? toBytesView(config.deviceProps)
-            : defaultDeviceProps(versionBase, config),
+            : defaultDeviceProps(versionBase, config, version),
         eRegid: intToBytes(4, registrationId),
-        eKeytype: intToBytes(1, KEY_TYPE_CURVE25519),
+        eKeytype: intToBytes(1, 5),
         eIdent: toBytesView(config.registrationInfo.identityKeyPair.pubKey),
         eSkeyId: intToBytes(3, signedPreKeyId),
         eSkeyVal: toBytesView(config.signedPreKey.keyPair.pubKey),

package/dist/esm/transport/noise/WaFrameCodec.js

@@ -1,4 +1,4 @@
-import { concatBytes, EMPTY_BYTES, toBytesView } from '../../util/bytes.js';
+import { EMPTY_BYTES, toBytesView } from '../../util/bytes.js';
 const WA_MAX_FRAME_LENGTH = (1 << 24) - 1;
 function frameLength(header) {
     return (header[0] << 16) | (header[1] << 8) | header[2];
@@ -15,6 +15,31 @@ export class WaFrameCodec {
         this.maxFrameLength = maxFrameLength;
         this.introSent = false;
         this.buffered = EMPTY_BYTES;
+        this.bufferedLength = 0;
+    }
+    assertFrameLength(length) {
+        if (length <= this.maxFrameLength) {
+            return;
+        }
+        throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
+    }
+    appendBuffered(chunk) {
+        if (chunk.length === 0) {
+            return;
+        }
+        if (this.bufferedLength === 0) {
+            this.buffered = chunk;
+        }
+        else {
+            const nextLength = this.bufferedLength + chunk.length;
+            if (this.buffered.length < nextLength) {
+                const nextBuffered = new Uint8Array(Math.max(nextLength, this.bufferedLength * 2));
+                nextBuffered.set(this.buffered.subarray(0, this.bufferedLength));
+                this.buffered = nextBuffered;
+            }
+            this.buffered.set(chunk, this.bufferedLength);
+        }
+        this.bufferedLength += chunk.length;
     }
     encodeFrame(frame) {
         if (frame.length > this.maxFrameLength) {
@@ -45,67 +70,56 @@ export class WaFrameCodec {
         }
         const frames = [];
         let chunkOffset = 0;
-        if (this.buffered.length > 0) {
-            if (this.buffered.length < 3) {
-                const missingHeaderBytes = 3 - this.buffered.length;
+        if (this.bufferedLength > 0) {
+            if (this.bufferedLength < 3) {
+                const missingHeaderBytes = 3 - this.bufferedLength;
                 if (chunk.length < missingHeaderBytes) {
-                    this.buffered = concatBytes([this.buffered, chunk]);
+                    this.appendBuffered(chunk);
                     return frames;
                 }
-                const header = new Uint8Array(3);
-                header.set(this.buffered, 0);
-                header.set(chunk.subarray(0, missingHeaderBytes), this.buffered.length);
-                const length = frameLength(header);
-                if (length > this.maxFrameLength) {
-                    throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
-                }
+                this.appendBuffered(chunk.subarray(0, missingHeaderBytes));
+                const length = frameLength(this.buffered);
+                this.assertFrameLength(length);
                 const remainingAfterHeader = chunk.length - missingHeaderBytes;
                 if (remainingAfterHeader < length) {
-                    const nextBuffered = new Uint8Array(3 + remainingAfterHeader);
-                    nextBuffered.set(header, 0);
-                    nextBuffered.set(chunk.subarray(missingHeaderBytes), 3);
-                    this.buffered = nextBuffered;
+                    this.appendBuffered(chunk.subarray(missingHeaderBytes));
                     return frames;
                 }
                 frames.push(chunk.subarray(missingHeaderBytes, missingHeaderBytes + length));
                 chunkOffset = missingHeaderBytes + length;
-                this.buffered = EMPTY_BYTES;
             }
             else {
-                const header = this.buffered.subarray(0, 3);
-                const length = frameLength(header);
-                if (length > this.maxFrameLength) {
-                    throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
-                }
-                const bufferedPayloadLength = this.buffered.length - 3;
+                const length = frameLength(this.buffered);
+                this.assertFrameLength(length);
+                const bufferedPayloadLength = this.bufferedLength - 3;
                 const missingPayloadBytes = length - bufferedPayloadLength;
                 if (missingPayloadBytes > chunk.length) {
-                    this.buffered = concatBytes([this.buffered, chunk]);
+                    this.appendBuffered(chunk);
                     return frames;
                 }
-                if (bufferedPayloadLength === 0) {
+                if (missingPayloadBytes === 0) {
+                    frames.push(this.buffered.subarray(3, 3 + length));
+                }
+                else if (bufferedPayloadLength === 0) {
                     frames.push(chunk.subarray(0, missingPayloadBytes));
                 }
                 else {
                     const frame = new Uint8Array(length);
-                    frame.set(this.buffered.subarray(3), 0);
-                    if (missingPayloadBytes > 0) {
-                        frame.set(chunk.subarray(0, missingPayloadBytes), bufferedPayloadLength);
-                    }
+                    frame.set(this.buffered.subarray(3, this.bufferedLength));
+                    frame.set(chunk.subarray(0, missingPayloadBytes), bufferedPayloadLength);
                     frames.push(frame);
                 }
                 chunkOffset = missingPayloadBytes;
-                this.buffered = EMPTY_BYTES;
             }
+            this.buffered = EMPTY_BYTES;
+            this.bufferedLength = 0;
         }
         const remainingChunk = chunk.subarray(chunkOffset);
         let offset = 0;
         while (remainingChunk.length - offset >= 3) {
             const header = remainingChunk.subarray(offset, offset + 3);
             const length = frameLength(header);
-            if (length > this.maxFrameLength) {
-                throw new Error(`incoming frame is too large: ${length} bytes (max allowed: ${this.maxFrameLength})`);
-            }
+            this.assertFrameLength(length);
             if (remainingChunk.length - offset - 3 < length) {
                 break;
             }
@@ -116,6 +130,7 @@ export class WaFrameCodec {
         }
         this.buffered =
             offset >= remainingChunk.length ? EMPTY_BYTES : remainingChunk.subarray(offset);
+        this.bufferedLength = this.buffered.length;
         return frames;
     }
 }

package/dist/esm/transport/noise/WaNoiseCert.js

@@ -1,9 +1,8 @@
-import { ed25519VerifyRaw, toSerializedPubKey } from '../../crypto/index.js';
+import { Ed25519, toSerializedPubKey } from '../../crypto/index.js';
 import { montgomeryToEdwardsPublic } from '../../crypto/curves/X25519.js';
 import { proto } from '../../proto.js';
 import { ROOT_CA_PUBLIC_KEY_HEX, ROOT_CA_SERIAL } from '../noise/constants.js';
-import { decodeProtoBytes } from '../../util/base64.js';
-import { hexToBytes, uint8Equal } from '../../util/bytes.js';
+import { assertByteLength, decodeProtoBytes, hexToBytes, uint8Equal } from '../../util/bytes.js';
 import { toSafeNumber } from '../../util/primitives.js';
 async function verifySignalVariant(serializedPublicKey, message, signatureInput) {
     const publicKey = toSerializedPubKey(serializedPublicKey);
@@ -18,7 +17,7 @@ async function verifySignalVariant(serializedPublicKey, message, signatureInput)
     const signBit = lastByte & 0x80;
     signature[63] = lastByte & 0x7f;
     const edwardsPublicKey = montgomeryToEdwardsPublic(publicKey.subarray(1), signBit);
-    return ed25519VerifyRaw(edwardsPublicKey, signature, message);
+    return Ed25519.verify(message, signature, edwardsPublicKey);
 }
 function parseNoiseCertificate(certificate) {
     if (!certificate) {
@@ -26,9 +25,7 @@ function parseNoiseCertificate(certificate) {
     }
     const detailsBytes = decodeProtoBytes(certificate.details, 'certificate.details');
     const signatureBytes = decodeProtoBytes(certificate.signature, 'certificate.signature');
-    if (signatureBytes.length !== 64) {
-        throw new Error('invalid certificate signature size');
-    }
+    assertByteLength(signatureBytes, 64, 'invalid certificate signature size');
     const details = proto.CertChain.NoiseCertificate.Details.decode(detailsBytes);
     const serial = toSafeNumber(details.serial, 'certificate.serial');
     const issuerSerial = toSafeNumber(details.issuerSerial, 'certificate.issuerSerial');

package/dist/esm/transport/noise/WaNoiseSession.js

@@ -1,6 +1,5 @@
 import { X25519 } from '../../crypto/index.js';
 import { ConsoleLogger } from '../../infra/log/ConsoleLogger.js';
-import { BoundedTaskQueue } from '../../infra/perf/BoundedTaskQueue.js';
 import { proto } from '../../proto.js';
 import { WA_DEFAULTS } from '../../protocol/constants.js';
 import { NOISE_IK_NAME, NOISE_XX_FALLBACK_NAME, NOISE_XX_NAME, WA_PROTO_HEADER } from '../noise/constants.js';
@@ -48,12 +47,11 @@ function buildRoutingInfoPrefix(routingInfo) {
 }
 export class WaNoiseSession {
     constructor(sendWire, logger = new ConsoleLogger('info')) {
-        this.sendWire = sendWire;
-        this.logger = logger;
-        this.writeQueue = new BoundedTaskQueue(4096, 1);
-        this.readQueue = new BoundedTaskQueue(4096, 1);
+        this.writeChain = Promise.resolve();
+        this.readChain = Promise.resolve();
         this.frameCodec = null;
         this.handshakeInbox = [];
+        this.handshakeInboxHead = 0;
         this.handshakeWaiter = null;
         this.handshakeRejecter = null;
         this.pendingDecryptedFrames = [];
@@ -61,6 +59,8 @@ export class WaNoiseSession {
         this.noiseSocket = null;
         this.serverStaticKey = null;
         this.handshakeFrameTimeoutMs = WA_DEFAULTS.CONNECT_TIMEOUT_MS;
+        this.sendWire = sendWire;
+        this.logger = logger;
     }
     async start(config) {
         this.reset();
@@ -92,12 +92,24 @@ export class WaNoiseSession {
         await this.decodeBufferedPostHandshakeFrames();
         this.logger.info('noise session established via full handshake');
     }
-    async encryptFrame(frame) {
-        if (!this.noiseSocket || !this.frameCodec) {
-            throw new Error('noise session is not established');
+    encryptFrame(frame) {
+        const socket = this.noiseSocket;
+        const codec = this.frameCodec;
+        if (!socket || !codec) {
+            return Promise.reject(new Error('noise session is not established'));
         }
-        const encrypted = await this.writeQueue.enqueue(() => this.noiseSocket.encrypt(frame));
-        return this.frameCodec.encodeFrame(encrypted);
+        let encryptPromise;
+        try {
+            encryptPromise = socket.encrypt(socket.reserveWriteNonce(), frame);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const result = this.writeChain
+            .then(() => encryptPromise)
+            .then((encrypted) => codec.encodeFrame(encrypted));
+        this.writeChain = result.then(() => { }, () => { });
+        return result;
     }
     async pushWireChunk(chunk) {
         const codec = this.frameCodec;
@@ -106,7 +118,9 @@ export class WaNoiseSession {
         }
         const out = [];
         if (this.pendingDecryptedFrames.length > 0) {
-            out.push(...this.pendingDecryptedFrames);
+            for (let i = 0; i < this.pendingDecryptedFrames.length; i += 1) {
+                out.push(this.pendingDecryptedFrames[i]);
+            }
             this.pendingDecryptedFrames = [];
         }
         const frames = codec.pushWireChunk(chunk);
@@ -124,9 +138,15 @@ export class WaNoiseSession {
             }
             return out;
         }
-        for (const frame of frames) {
-            const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
-            out.push(decrypted);
+        if (frames.length > 0) {
+            const decryptBatch = this.decryptFramesBatch(this.noiseSocket, frames);
+            this.readChain = this.readChain
+                .then(() => decryptBatch)
+                .then(() => { }, () => { });
+            const decrypted = await decryptBatch;
+            for (let i = 0; i < decrypted.length; i++) {
+                out.push(decrypted[i]);
+            }
         }
         return out;
     }
@@ -141,21 +161,30 @@ export class WaNoiseSession {
             rejecter(closeError);
         }
     }
+    async decryptFramesBatch(socket, frames) {
+        if (frames.length === 1) {
+            return [await socket.decrypt(socket.reserveReadNonce(), frames[0])];
+        }
+        const pending = new Array(frames.length);
+        for (let i = 0; i < frames.length; i++) {
+            pending[i] = socket.decrypt(socket.reserveReadNonce(), frames[i]);
+        }
+        return Promise.all(pending);
+    }
     reset() {
         this.logger.trace('noise session reset');
         this.frameCodec = null;
-        this.handshakeInbox = [];
+        this.handshakeInbox.length = this.handshakeInboxHead = 0;
         this.handshakeWaiter = null;
         this.handshakeRejecter = null;
         this.pendingDecryptedFrames = [];
         this.closedError = null;
         this.noiseSocket = null;
         this.serverStaticKey = null;
+        this.writeChain = Promise.resolve();
+        this.readChain = Promise.resolve();
     }
     getServerStaticKey() {
-        if (!this.serverStaticKey) {
-            return null;
-        }
         return this.serverStaticKey;
     }
     async fullHandshake(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates) {
@@ -185,10 +214,12 @@ export class WaNoiseSession {
         await handshake.start(NOISE_IK_NAME, protocolHeader);
         await handshake.authenticate(serverStaticKey);
         await handshake.authenticate(ephemeralKeyPair.pubKey);
-        const agreement1 = await X25519.scalarMult(ephemeralKeyPair.privKey, serverStaticKey);
+        const [agreement1, agreement2] = await Promise.all([
+            X25519.scalarMult(ephemeralKeyPair.privKey, serverStaticKey),
+            X25519.scalarMult(clientStaticKeyPair.privKey, serverStaticKey)
+        ]);
         await handshake.mixIntoKey(agreement1);
         const encryptedClientStatic = await handshake.encrypt(clientStaticKeyPair.pubKey);
-        const agreement2 = await X25519.scalarMult(clientStaticKeyPair.privKey, serverStaticKey);
         await handshake.mixIntoKey(agreement2);
         const encryptedPayload = await handshake.encrypt(payload);
         const clientHello = proto.HandshakeMessage.encode({
@@ -215,8 +246,12 @@ export class WaNoiseSession {
         }
         const serverEphemeral = toBytesView(serverHello.ephemeral);
         await handshake.authenticate(serverEphemeral);
-        await handshake.mixIntoKey(await X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral));
-        await handshake.mixIntoKey(await X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral));
+        const [dh1, dh2] = await Promise.all([
+            X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral),
+            X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral)
+        ]);
+        await handshake.mixIntoKey(dh1);
+        await handshake.mixIntoKey(dh2);
         await handshake.decrypt(toBytesView(serverHello.payload));
         this.serverStaticKey = serverStaticKey;
         this.logger.info('noise resume handshake successful without fallback');
@@ -275,8 +310,13 @@ export class WaNoiseSession {
         if (this.closedError) {
             throw this.closedError;
         }
-        const queued = this.handshakeInbox.shift();
+        const queued = this.handshakeInboxHead < this.handshakeInbox.length
+            ? this.handshakeInbox[this.handshakeInboxHead++]
+            : undefined;
         if (queued) {
+            if (this.handshakeInboxHead === this.handshakeInbox.length) {
+                this.handshakeInbox.length = this.handshakeInboxHead = 0;
+            }
             this.logger.trace('noise handshake frame consumed from queue');
             return queued;
         }
@@ -307,16 +347,24 @@ export class WaNoiseSession {
         });
     }
     async decodeBufferedPostHandshakeFrames() {
-        if (!this.noiseSocket || this.handshakeInbox.length === 0) {
+        if (!this.noiseSocket || this.handshakeInboxHead >= this.handshakeInbox.length) {
             return;
         }
         this.logger.debug('decoding buffered post-handshake frames', {
-            count: this.handshakeInbox.length
+            count: this.handshakeInbox.length - this.handshakeInboxHead
         });
-        const buffered = this.handshakeInbox.splice(0, this.handshakeInbox.length);
-        for (const frame of buffered) {
-            const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
-            this.pendingDecryptedFrames.push(decrypted);
+        const start = this.handshakeInboxHead;
+        const frames = this.handshakeInbox.slice(start);
+        if (frames.length > 0) {
+            const decryptBatch = this.decryptFramesBatch(this.noiseSocket, frames);
+            this.readChain = this.readChain
+                .then(() => decryptBatch)
+                .then(() => { }, () => { });
+            const decrypted = await decryptBatch;
+            for (let i = 0; i < decrypted.length; i++) {
+                this.pendingDecryptedFrames.push(decrypted[i]);
+            }
         }
+        this.handshakeInbox.length = this.handshakeInboxHead = 0;
     }
 }