zapo-js 0.1.0 → 0.1.2

package/dist/esm/transport/binary/encoder.js

@@ -167,14 +167,22 @@ function writeListSize(size, writer) {
     writer.writeUint16(size);
 }
 function writeNodeInternal(node, writer) {
-    const attrs = Object.entries(node.attrs);
+    let attrsLen = 0;
+    for (const key in node.attrs) {
+        if (Object.prototype.hasOwnProperty.call(node.attrs, key)) {
+            attrsLen += 1;
+        }
+    }
     const hasContent = node.content !== null && node.content !== undefined;
-    const listSize = 1 + attrs.length * 2 + (hasContent ? 1 : 0);
+    const listSize = 1 + attrsLen * 2 + (hasContent ? 1 : 0);
     writeListSize(listSize, writer);
     writeString(node.tag, writer);
-    for (const [key, value] of attrs) {
+    for (const key in node.attrs) {
+        if (!Object.prototype.hasOwnProperty.call(node.attrs, key)) {
+            continue;
+        }
         writeString(key, writer);
-        writeString(value, writer);
+        writeString(node.attrs[key], writer);
     }
     if (!hasContent) {
         return;

package/dist/esm/transport/index.js

@@ -1,3 +1,4 @@
+export { isProxyAgent, isProxyDispatcher, isProxyTransport, toProxyAgent, toProxyDispatcher } from './proxy.js';
 export { WaComms } from './WaComms.js';
 export { WaWebSocket } from './WaWebSocket.js';
 export { WaKeepAlive } from './keepalive/WaKeepAlive.js';

package/dist/esm/transport/keepalive/WaKeepAlive.js

@@ -1,5 +1,5 @@
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
-import { toError } from '../../util/primitives.js';
+import { normalizeNonNegativeInteger, toError } from '../../util/primitives.js';
 const KEEPALIVE_DEFAULT_JITTER_RATIO = 0.1;
 const KEEPALIVE_DEFAULT_MIN_JITTER_MS = 250;
 const KEEPALIVE_MAX_JITTER_RATIO = 0.5;
@@ -12,7 +12,7 @@ export class WaKeepAlive {
         this.timeoutMs = options.timeoutMs ?? WA_DEFAULTS.DEAD_SOCKET_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
         this.jitterRatio = this.normalizeJitterRatio(options.jitterRatio);
-        this.minJitterMs = this.normalizeMinJitterMs(options.minJitterMs);
+        this.minJitterMs = normalizeNonNegativeInteger(options.minJitterMs, KEEPALIVE_DEFAULT_MIN_JITTER_MS);
         this.timer = null;
         this.generation = 0;
         this.inFlight = false;
@@ -110,12 +110,6 @@ export class WaKeepAlive {
         const normalized = value;
         return Math.min(Math.max(normalized, 0), KEEPALIVE_MAX_JITTER_RATIO);
     }
-    normalizeMinJitterMs(value) {
-        if (!Number.isFinite(value)) {
-            return KEEPALIVE_DEFAULT_MIN_JITTER_MS;
-        }
-        return Math.max(0, Math.trunc(value));
-    }
     computeNextDelayMs() {
         if (this.intervalMs <= 0) {
             return 0;

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

@@ -1,5 +1,6 @@
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
 import { toError } from '../../util/primitives.js';
+import { formatNodeIdPrefixFromSeed } from './helpers.js';
 export class WaNodeOrchestrator {
     constructor(options) {
         this.logger = options.logger;
@@ -133,10 +134,7 @@ export class WaNodeOrchestrator {
         return this.stanzaPrefix;
     }
     generateStanzaPrefix() {
-        const seed = crypto.getRandomValues(new Uint8Array(4));
-        const left = seed[0] * 256 + seed[1];
-        const right = seed[2] * 256 + seed[3];
-        const prefix = `${left}.${right}-`;
+        const prefix = formatNodeIdPrefixFromSeed(crypto.getRandomValues(new Uint8Array(4)));
         this.logger.debug('generated stanza prefix', { prefix });
         return prefix;
     }

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

@@ -9,9 +9,6 @@ export class WaNodeTransport extends EventEmitter {
         this.logger = logger;
         this.comms = null;
     }
-    on(event, listener) {
-        return super.on(event, listener);
-    }
     bindComms(comms) {
         this.comms = comms;
         this.logger.debug('node transport bindComms', { connected: comms !== null });

package/dist/esm/transport/node/builders/{accountSync.js → account-sync.js}

@@ -1,42 +1,22 @@
-import { WA_DEFAULTS, WA_NODE_TAGS, WA_XMLNS } from '../../../protocol/constants.js';
+import { WA_DEFAULTS, WA_NODE_TAGS, WA_USYNC_CONTEXTS, WA_XMLNS } from '../../../protocol/constants.js';
+import { buildUsyncIq } from '../../node/builders/usync.js';
 import { buildIqNode } from '../../node/query.js';
 export function buildAccountDevicesSyncIq(userJids, sid) {
-    return buildIqNode('get', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.USYNC, [
-        {
-            tag: WA_NODE_TAGS.USYNC,
-            attrs: {
-                sid,
-                index: '0',
-                last: 'true',
-                mode: WA_NODE_TAGS.QUERY,
-                context: WA_NODE_TAGS.NOTIFICATION
-            },
-            content: [
-                {
-                    tag: WA_NODE_TAGS.QUERY,
-                    attrs: {},
-                    content: [
-                        {
-                            tag: WA_NODE_TAGS.DEVICES,
-                            attrs: {
-                                version: '2'
-                            }
-                        }
-                    ]
-                },
-                {
-                    tag: WA_NODE_TAGS.LIST,
-                    attrs: {},
-                    content: userJids.map((jid) => ({
-                        tag: WA_NODE_TAGS.USER,
-                        attrs: {
-                            jid
-                        }
-                    }))
+    return buildUsyncIq({
+        sid,
+        context: WA_USYNC_CONTEXTS.NOTIFICATION,
+        queryProtocolNodes: [
+            {
+                tag: WA_NODE_TAGS.DEVICES,
+                attrs: {
+                    version: '2'
                 }
-            ]
-        }
-    ]);
+            }
+        ],
+        users: userJids.map((jid) => ({
+            jid
+        }))
+    });
 }
 export function buildAccountPictureSyncIq(meJid) {
     return buildIqNode('get', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.PROFILE_PICTURE, [

package/dist/esm/transport/node/builders/index.js

@@ -1,7 +1,8 @@
-export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/accountSync.js';
+export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/account-sync.js';
 export { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode, buildIqResultNode, buildNotificationAckNode } from '../../node/builders/pairing.js';
 export { buildMediaConnIq } from '../../node/builders/media.js';
 export { buildDirectMessageFanoutNode, buildGroupDirectMessageNode, buildGroupRetryMessageNode, buildGroupSenderKeyMessageNode, buildInboundDeliveryReceiptNode, buildInboundMessageAckNode, buildInboundReceiptAckNode, buildInboundRetryReceiptNode, buildInboundRetryReceiptAckNode } from '../../node/builders/message.js';
 export { buildRetryReceiptNode } from '../../node/builders/retry.js';
 export { buildMissingPreKeysFetchIq, buildPreKeyUploadIq, buildSignedPreKeyRotateIq } from '../../node/builders/prekeys.js';
 export { buildCreateGroupIq, buildGroupParticipantChangeIq, buildLeaveGroupIq } from '../../node/builders/group.js';
+export { buildUsyncIq, buildUsyncUserNode } from '../../node/builders/usync.js';

package/dist/esm/transport/node/builders/message.js

@@ -39,6 +39,9 @@ export function buildDirectMessageFanoutNode(input) {
             content: input.deviceIdentity
         });
     }
+    if (input.reportingNode) {
+        content.push(input.reportingNode);
+    }
     return {
         tag: WA_MESSAGE_TAGS.MESSAGE,
         attrs,
@@ -97,6 +100,9 @@ export function buildGroupSenderKeyMessageNode(input) {
             content: input.deviceIdentity
         });
     }
+    if (input.reportingNode) {
+        content.push(input.reportingNode);
+    }
     return {
         tag: WA_MESSAGE_TAGS.MESSAGE,
         attrs,
@@ -149,6 +155,9 @@ export function buildGroupDirectMessageNode(input) {
             content: input.deviceIdentity
         });
     }
+    if (input.reportingNode) {
+        content.push(input.reportingNode);
+    }
     return {
         tag: WA_MESSAGE_TAGS.MESSAGE,
         attrs,

package/dist/esm/transport/node/builders/pairing.js

@@ -1,6 +1,5 @@
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_SIGNALING, WA_XMLNS } from '../../../protocol/constants.js';
-const ZERO_BYTE = new Uint8Array([0]);
-const NOTIFICATION_CLASS = WA_NODE_TAGS.NOTIFICATION;
+import { ZERO_BYTES } from '../../../util/bytes.js';
 export function buildCompanionHelloRequestNode(args) {
     return {
         tag: WA_NODE_TAGS.IQ,
@@ -43,7 +42,7 @@ export function buildCompanionHelloRequestNode(args) {
                     {
                         tag: 'link_code_pairing_nonce',
                         attrs: {},
-                        content: ZERO_BYTE
+                        content: ZERO_BYTES
                     }
                 ]
             }
@@ -107,8 +106,8 @@ export function buildCompanionFinishRequestNode(args) {
 export function buildNotificationAckNode(node, typeOverride) {
     const attrs = {
         to: node.attrs.from ?? WA_DEFAULTS.HOST_DOMAIN,
-        class: NOTIFICATION_CLASS,
-        type: typeOverride ?? node.attrs.type ?? NOTIFICATION_CLASS
+        class: WA_NODE_TAGS.NOTIFICATION,
+        type: typeOverride ?? node.attrs.type ?? WA_NODE_TAGS.NOTIFICATION
     };
     if (node.attrs.id) {
         attrs.id = node.attrs.id;

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

@@ -0,0 +1,41 @@
+import { WA_DEFAULTS, WA_NODE_TAGS, WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES, WA_XMLNS } from '../../../protocol/constants.js';
+import { buildIqNode } from '../../node/query.js';
+export function buildUsyncUserNode(input) {
+    return {
+        tag: WA_NODE_TAGS.USER,
+        attrs: {
+            ...input.attrs,
+            jid: input.jid
+        },
+        ...(input.content !== undefined ? { content: input.content } : {})
+    };
+}
+export function buildUsyncIq(input) {
+    if (input.queryProtocolNodes.length === 0) {
+        throw new Error('usync query must include at least one protocol node');
+    }
+    return buildIqNode('get', input.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.USYNC, [
+        {
+            tag: WA_NODE_TAGS.USYNC,
+            attrs: {
+                sid: input.sid,
+                index: input.index ?? WA_USYNC_DEFAULTS.INDEX,
+                last: input.last ?? WA_USYNC_DEFAULTS.LAST,
+                mode: input.mode ?? WA_USYNC_MODES.QUERY,
+                context: input.context ?? WA_USYNC_CONTEXTS.INTERACTIVE
+            },
+            content: [
+                {
+                    tag: WA_NODE_TAGS.QUERY,
+                    attrs: {},
+                    content: [...input.queryProtocolNodes]
+                },
+                {
+                    tag: WA_NODE_TAGS.LIST,
+                    attrs: {},
+                    content: input.users.map((user) => buildUsyncUserNode(user))
+                }
+            ]
+        }
+    ]);
+}

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

@@ -1,15 +1,112 @@
-import { base64ToBytes, TEXT_ENCODER } from '../../util/bytes.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([]);
 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;
+    return content.map((c) => c.tag);
+}
+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 +125,15 @@ 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}-`;
+}

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

@@ -0,0 +1,35 @@
+import { randomBytesAsync } from '../../crypto/index.js';
+import { formatNodeIdPrefixFromSeed } from './helpers.js';
+export function createUsyncSidGenerator() {
+    const state = {
+        prefix: null,
+        prefixPromise: null,
+        counter: 1
+    };
+    return async () => {
+        const prefix = await getUsyncPrefix(state);
+        const sid = `${prefix}${state.counter}`;
+        state.counter += 1;
+        return sid;
+    };
+}
+async function getUsyncPrefix(state) {
+    if (state.prefix) {
+        return state.prefix;
+    }
+    if (!state.prefixPromise) {
+        state.prefixPromise = buildUsyncPrefix()
+            .then((prefix) => {
+            state.prefix = prefix;
+            return prefix;
+        })
+            .finally(() => {
+            state.prefixPromise = null;
+        });
+    }
+    return state.prefixPromise;
+}
+async function buildUsyncPrefix() {
+    const seed = await randomBytesAsync(4);
+    return formatNodeIdPrefixFromSeed(seed);
+}

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

@@ -2,12 +2,11 @@ import { ed25519VerifyRaw, 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);
-    if (signatureInput.length !== 64) {
+    if (!assertByteLength(signatureInput, 64, 'invalid certificate signature size', false)) {
         return false;
     }
     const signature = new Uint8Array(signatureInput);
@@ -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

@@ -48,12 +48,9 @@ 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.frameCodec = null;
         this.handshakeInbox = [];
+        this.handshakeInboxHead = 0;
         this.handshakeWaiter = null;
         this.handshakeRejecter = null;
         this.pendingDecryptedFrames = [];
@@ -61,6 +58,10 @@ export class WaNoiseSession {
         this.noiseSocket = null;
         this.serverStaticKey = null;
         this.handshakeFrameTimeoutMs = WA_DEFAULTS.CONNECT_TIMEOUT_MS;
+        this.sendWire = sendWire;
+        this.logger = logger;
+        this.writeQueue = new BoundedTaskQueue(4096, 1);
+        this.readQueue = new BoundedTaskQueue(4096, 1);
     }
     async start(config) {
         this.reset();
@@ -144,7 +145,7 @@ export class WaNoiseSession {
     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 = [];
@@ -275,8 +276,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 +313,17 @@ 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) {
+        for (let index = this.handshakeInboxHead; index < this.handshakeInbox.length; index += 1) {
+            const frame = this.handshakeInbox[index];
             const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
             this.pendingDecryptedFrames.push(decrypted);
         }
+        this.handshakeInbox.length = this.handshakeInboxHead = 0;
     }
 }