zapo-js 0.1.1 → 0.2.0

package/dist/transport/node/helpers.js

@@ -4,21 +4,131 @@ exports.getNodeChildren = getNodeChildren;
 exports.findNodeChild = findNodeChild;
 exports.getFirstNodeChild = getFirstNodeChild;
 exports.getNodeChildrenByTag = getNodeChildrenByTag;
+exports.getNodeChildrenByTagFromChildren = getNodeChildrenByTagFromChildren;
+exports.getNodeChildrenTags = getNodeChildrenTags;
+exports.getNodeChildrenNonEmptyAttrValuesByTag = getNodeChildrenNonEmptyAttrValuesByTag;
+exports.getNodeChildrenNonEmptyUtf8ByTag = getNodeChildrenNonEmptyUtf8ByTag;
+exports.findNodeChildrenByTags = findNodeChildrenByTags;
 exports.hasNodeChild = hasNodeChild;
 exports.decodeNodeContentUtf8OrBytes = decodeNodeContentUtf8OrBytes;
 exports.decodeNodeContentBase64OrBytes = decodeNodeContentBase64OrBytes;
+exports.formatNodeIdPrefixFromSeed = formatNodeIdPrefixFromSeed;
+exports.createNodeIdGenerator = createNodeIdGenerator;
+const _crypto_1 = require("../../crypto/index.js");
 const bytes_1 = require("../../util/bytes");
+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);
 function getNodeChildren(node) {
-    return Array.isArray(node.content) ? node.content : [];
+    return Array.isArray(node.content) ? node.content : EMPTY_NODE_CHILDREN;
 }
 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];
+    }
 }
 function getFirstNodeChild(node) {
     return getNodeChildren(node)[0];
 }
 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;
+}
+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;
+}
+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;
+}
+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;
+}
+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 = bytes_1.TEXT_DECODER.decode(decodeNodeContentUtf8OrBytes(raw, field));
+        if (value.length === 0) {
+            continue;
+        }
+        if (!values) {
+            values = [];
+        }
+        values.push(value);
+    }
+    return values ?? EMPTY_NODE_VALUES;
+}
+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;
 }
 function hasNodeChild(node, tag) {
     return findNodeChild(node, tag) !== undefined;
@@ -37,10 +147,27 @@ function decodeNodeContentBase64OrBytes(value, field) {
         throw new Error(`missing binary node content for ${field}`);
     }
     if (typeof value === 'string') {
-        return (0, bytes_1.base64ToBytes)(value);
+        return (0, bytes_1.base64ToBytesChecked)(value, field);
     }
     if (value instanceof Uint8Array) {
         return value;
     }
     throw new Error(`missing binary node content for ${field}`);
 }
+function formatNodeIdPrefixFromSeed(seed) {
+    const left = ((seed[0] << 8) | seed[1]) >>> 0;
+    const right = ((seed[2] << 8) | seed[3]) >>> 0;
+    return `${left}.${right}-`;
+}
+async function createNodeIdGenerator() {
+    await (0, _crypto_1.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/transport/node/usync.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUsyncSidGenerator = createUsyncSidGenerator;
+const helpers_1 = require("./helpers");
+function createUsyncSidGenerator() {
+    const generatorPromise = (0, helpers_1.createNodeIdGenerator)();
+    return async () => (await generatorPromise).next();
+}

package/dist/transport/node/xml.js

@@ -4,23 +4,41 @@ exports.formatBinaryNodeAsXml = formatBinaryNodeAsXml;
 const bytes_1 = require("../../util/bytes");
 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}/>`;
@@ -34,7 +52,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}>`;
 }
 function formatBinaryNodeAsXml(node) {

package/dist/transport/noise/WaClientPayload.js

@@ -5,8 +5,7 @@ exports.buildRegistrationPayload = buildRegistrationPayload;
 const node_crypto_1 = require("node:crypto");
 const primitives_1 = require("../../crypto/core/primitives");
 const _proto_1 = require("../../proto.js");
-const constants_1 = require("../../signal/constants");
-const constants_2 = require("../noise/constants");
+const constants_1 = require("../noise/constants");
 const bytes_1 = require("../../util/bytes");
 function parseVersion(versionBase) {
     const [p = '2', s = '3000', t = '0'] = versionBase.split('.');
@@ -64,8 +63,8 @@ function resolveDevicePropsPlatformType(deviceBrowser) {
             return _proto_1.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_1.proto.ClientPayload.UserAgent.Platform.WEB,
@@ -86,8 +85,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_1.proto.DeviceProps.encode({
         os: config.deviceOsDisplayName ?? process.platform,
         version: {
@@ -109,15 +108,15 @@ function defaultDeviceProps(versionBase, config) {
         }
     }).finish();
 }
-function buildCommonPayload(config) {
-    const versionBase = config.versionBase ?? constants_2.DEFAULT_VERSION_BASE;
+function buildCommonPayload(config, version) {
+    const versionBase = config.versionBase ?? constants_1.DEFAULT_VERSION_BASE;
     const pull = config.pull ?? true;
     return {
         passive: config.passive === true,
         pull,
         connectType: _proto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
         connectReason: _proto_1.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()
@@ -145,15 +144,16 @@ function buildRegistrationPayload(config) {
     if (!Number.isSafeInteger(signedPreKeyId) || signedPreKeyId <= 0) {
         throw new Error('registration payload requires a valid signedPreKeyId');
     }
-    const versionBase = config.versionBase ?? constants_2.DEFAULT_VERSION_BASE;
-    const common = buildCommonPayload(config);
+    const versionBase = config.versionBase ?? constants_1.DEFAULT_VERSION_BASE;
+    const version = parseVersion(versionBase);
+    const common = buildCommonPayload(config, version);
     const devicePairingData = {
         buildHash: config.buildHash ? (0, bytes_1.toBytesView)(config.buildHash) : (0, primitives_1.md5Bytes)(versionBase),
         deviceProps: config.deviceProps
             ? (0, bytes_1.toBytesView)(config.deviceProps)
-            : defaultDeviceProps(versionBase, config),
+            : defaultDeviceProps(versionBase, config, version),
         eRegid: (0, bytes_1.intToBytes)(4, registrationId),
-        eKeytype: (0, bytes_1.intToBytes)(1, constants_1.KEY_TYPE_CURVE25519),
+        eKeytype: (0, bytes_1.intToBytes)(1, 5),
         eIdent: (0, bytes_1.toBytesView)(config.registrationInfo.identityKeyPair.pubKey),
         eSkeyId: (0, bytes_1.intToBytes)(3, signedPreKeyId),
         eSkeyVal: (0, bytes_1.toBytesView)(config.signedPreKey.keyPair.pubKey),

package/dist/transport/noise/WaFrameCodec.js

@@ -18,6 +18,31 @@ class WaFrameCodec {
         this.maxFrameLength = maxFrameLength;
         this.introSent = false;
         this.buffered = bytes_1.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) {
@@ -48,67 +73,56 @@ 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 = (0, bytes_1.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 = bytes_1.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 = (0, bytes_1.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 = bytes_1.EMPTY_BYTES;
             }
+            this.buffered = bytes_1.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;
             }
@@ -119,6 +133,7 @@ class WaFrameCodec {
         }
         this.buffered =
             offset >= remainingChunk.length ? bytes_1.EMPTY_BYTES : remainingChunk.subarray(offset);
+        this.bufferedLength = this.buffered.length;
         return frames;
     }
 }

package/dist/transport/noise/WaNoiseCert.js

@@ -5,7 +5,6 @@ const _crypto_1 = require("../../crypto/index.js");
 const X25519_1 = require("../../crypto/curves/X25519");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../noise/constants");
-const base64_1 = require("../../util/base64");
 const bytes_1 = require("../../util/bytes");
 const primitives_1 = require("../../util/primitives");
 async function verifySignalVariant(serializedPublicKey, message, signatureInput) {
@@ -21,21 +20,19 @@ async function verifySignalVariant(serializedPublicKey, message, signatureInput)
     const signBit = lastByte & 0x80;
     signature[63] = lastByte & 0x7f;
     const edwardsPublicKey = (0, X25519_1.montgomeryToEdwardsPublic)(publicKey.subarray(1), signBit);
-    return (0, _crypto_1.ed25519VerifyRaw)(edwardsPublicKey, signature, message);
+    return _crypto_1.Ed25519.verify(message, signature, edwardsPublicKey);
 }
 function parseNoiseCertificate(certificate) {
     if (!certificate) {
         throw new Error('missing noise certificate');
     }
-    const detailsBytes = (0, base64_1.decodeProtoBytes)(certificate.details, 'certificate.details');
-    const signatureBytes = (0, base64_1.decodeProtoBytes)(certificate.signature, 'certificate.signature');
-    if (signatureBytes.length !== 64) {
-        throw new Error('invalid certificate signature size');
-    }
+    const detailsBytes = (0, bytes_1.decodeProtoBytes)(certificate.details, 'certificate.details');
+    const signatureBytes = (0, bytes_1.decodeProtoBytes)(certificate.signature, 'certificate.signature');
+    (0, bytes_1.assertByteLength)(signatureBytes, 64, 'invalid certificate signature size');
     const details = _proto_1.proto.CertChain.NoiseCertificate.Details.decode(detailsBytes);
     const serial = (0, primitives_1.toSafeNumber)(details.serial, 'certificate.serial');
     const issuerSerial = (0, primitives_1.toSafeNumber)(details.issuerSerial, 'certificate.issuerSerial');
-    const key = (0, base64_1.decodeProtoBytes)(details.key, 'certificate.key');
+    const key = (0, bytes_1.decodeProtoBytes)(details.key, 'certificate.key');
     return {
         serial,
         issuerSerial,