zapo-js 0.1.0 → 0.1.2

package/dist/transport/node/helpers.js

@@ -4,21 +4,124 @@ 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;
 const bytes_1 = require("../../util/bytes");
+const EMPTY_NODE_CHILDREN = Object.freeze([]);
+const EMPTY_NODE_TAGS = Object.freeze([]);
+const EMPTY_NODE_VALUES = Object.freeze([]);
 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;
+    return content.map((c) => c.tag);
+}
+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 +140,15 @@ 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}-`;
+}

package/dist/transport/node/usync.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUsyncSidGenerator = createUsyncSidGenerator;
+const _crypto_1 = require("../../crypto/index.js");
+const helpers_1 = require("./helpers");
+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 (0, _crypto_1.randomBytesAsync)(4);
+    return (0, helpers_1.formatNodeIdPrefixFromSeed)(seed);
+}

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,12 +5,11 @@ 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) {
     const publicKey = (0, _crypto_1.toSerializedPubKey)(serializedPublicKey);
-    if (signatureInput.length !== 64) {
+    if (!(0, bytes_1.assertByteLength)(signatureInput, 64, 'invalid certificate signature size', false)) {
         return false;
     }
     const signature = new Uint8Array(signatureInput);
@@ -27,15 +26,13 @@ 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,

package/dist/transport/noise/WaNoiseSession.js

@@ -51,12 +51,9 @@ function buildRoutingInfoPrefix(routingInfo) {
 }
 class WaNoiseSession {
     constructor(sendWire, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
-        this.sendWire = sendWire;
-        this.logger = logger;
-        this.writeQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
-        this.readQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
         this.frameCodec = null;
         this.handshakeInbox = [];
+        this.handshakeInboxHead = 0;
         this.handshakeWaiter = null;
         this.handshakeRejecter = null;
         this.pendingDecryptedFrames = [];
@@ -64,6 +61,10 @@ class WaNoiseSession {
         this.noiseSocket = null;
         this.serverStaticKey = null;
         this.handshakeFrameTimeoutMs = constants_1.WA_DEFAULTS.CONNECT_TIMEOUT_MS;
+        this.sendWire = sendWire;
+        this.logger = logger;
+        this.writeQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
+        this.readQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
     }
     async start(config) {
         this.reset();
@@ -147,7 +148,7 @@ 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 = [];
@@ -278,8 +279,13 @@ 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;
         }
@@ -310,17 +316,18 @@ 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;
     }
 }
 exports.WaNoiseSession = WaNoiseSession;

package/dist/transport/proxy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProxyDispatcher = isProxyDispatcher;
+exports.isProxyAgent = isProxyAgent;
+exports.isProxyTransport = isProxyTransport;
+exports.toProxyDispatcher = toProxyDispatcher;
+exports.toProxyAgent = toProxyAgent;
+function isProxyDispatcher(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'dispatch' in value &&
+        typeof value.dispatch === 'function');
+}
+function isProxyAgent(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'addRequest' in value &&
+        typeof value.addRequest === 'function');
+}
+function isProxyTransport(value) {
+    return isProxyDispatcher(value) || isProxyAgent(value);
+}
+function toProxyDispatcher(proxy) {
+    if (!proxy || !isProxyDispatcher(proxy)) {
+        return undefined;
+    }
+    return proxy;
+}
+function toProxyAgent(proxy) {
+    if (!proxy || !isProxyAgent(proxy)) {
+        return undefined;
+    }
+    return proxy;
+}

package/dist/transport/stream/parse.js

@@ -1,80 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStreamControlNode = parseStreamControlNode;
-exports.parseOptionalInt = parseOptionalInt;
 exports.parseCompanionEncStatic = parseCompanionEncStatic;
 exports.parseSuccessPersistAttributes = parseSuccessPersistAttributes;
 const constants_1 = require("../../protocol/constants");
 const helpers_1 = require("../node/helpers");
-const base64_1 = require("../../util/base64");
-function parseStrictUnsignedInt(value) {
-    if (!/^\d+$/.test(value)) {
-        return undefined;
-    }
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed)) {
-        return undefined;
-    }
-    return parsed;
-}
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
 function parseStreamControlNode(node) {
     if (node.tag === constants_1.WA_STREAM_SIGNALING.XML_STREAM_END_TAG) {
-        return {
-            kind: 'xmlstreamend'
-        };
+        return { kind: 'xmlstreamend' };
     }
     if (node.tag !== constants_1.WA_STREAM_SIGNALING.STREAM_ERROR_TAG) {
         return null;
     }
     const conflictNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_STREAM_SIGNALING.CONFLICT_TAG);
     if (conflictNode) {
-        if (conflictNode.attrs.type === constants_1.WA_STREAM_SIGNALING.REPLACED_TYPE) {
-            return {
-                kind: 'stream_error_replaced'
-            };
-        }
-        return {
-            kind: 'stream_error_device_removed'
-        };
+        return conflictNode.attrs.type === constants_1.WA_STREAM_SIGNALING.REPLACED_TYPE
+            ? { kind: 'stream_error_replaced' }
+            : { kind: 'stream_error_device_removed' };
     }
-    const codeRaw = node.attrs.code;
-    if (codeRaw) {
-        const code = parseStrictUnsignedInt(codeRaw);
-        if (code !== undefined) {
-            return {
-                kind: 'stream_error_code',
-                code
-            };
-        }
+    const code = node.attrs.code ? (0, primitives_1.parseStrictUnsignedInt)(node.attrs.code) : undefined;
+    if (code !== undefined) {
+        return { kind: 'stream_error_code', code };
     }
     const ackNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_STREAM_SIGNALING.ACK_TAG);
     if (ackNode) {
-        return {
-            kind: 'stream_error_ack',
-            id: ackNode.attrs.id
-        };
+        return { kind: 'stream_error_ack', id: ackNode.attrs.id };
     }
     if ((0, helpers_1.hasNodeChild)(node, constants_1.WA_STREAM_SIGNALING.XML_NOT_WELL_FORMED_TAG)) {
-        return {
-            kind: 'stream_error_xml_not_well_formed'
-        };
-    }
-    return {
-        kind: 'stream_error_other'
-    };
-}
-function parseOptionalInt(value) {
-    if (!value) {
-        return undefined;
+        return { kind: 'stream_error_xml_not_well_formed' };
     }
-    return parseStrictUnsignedInt(value);
+    return { kind: 'stream_error_other' };
 }
 function parseCompanionEncStatic(value, onError) {
     if (!value) {
         return undefined;
     }
     try {
-        return (0, base64_1.base64ToBytes)(value, 'success.companion_enc_static');
+        return (0, bytes_1.base64ToBytesChecked)(value, 'success.companion_enc_static');
     }
     catch (error) {
         if (error instanceof Error) {
@@ -88,10 +52,10 @@ function parseSuccessPersistAttributes(node, onCompanionParseError) {
         meLid: node.attrs.lid,
         meDisplayName: node.attrs.display_name,
         companionEncStatic: parseCompanionEncStatic(node.attrs.companion_enc_static, onCompanionParseError),
-        lastSuccessTs: parseOptionalInt(node.attrs.t),
-        propsVersion: parseOptionalInt(node.attrs.props),
-        abPropsVersion: parseOptionalInt(node.attrs.abprops),
+        lastSuccessTs: (0, primitives_1.parseOptionalInt)(node.attrs.t),
+        propsVersion: (0, primitives_1.parseOptionalInt)(node.attrs.props),
+        abPropsVersion: (0, primitives_1.parseOptionalInt)(node.attrs.abprops),
         connectionLocation: node.attrs.location,
-        accountCreationTs: parseOptionalInt(node.attrs.creation)
+        accountCreationTs: (0, primitives_1.parseOptionalInt)(node.attrs.creation)
     };
 }

package/dist/types/appstate/WaAppStateCrypto.d.ts

@@ -53,7 +53,6 @@ export declare class WaAppStateCrypto {
     private pointwiseWithOverflow;
     private generateAssociatedData;
     private generateValueMac;
-    private normalizeDerivedKeysCacheMaxSize;
     private touchDerivedKeysCacheEntry;
 }
 export {};

package/dist/types/appstate/WaAppStateSyncClient.d.ts

@@ -7,6 +7,7 @@ interface WaAppStateSyncClientOptions {
     readonly logger: Logger;
     readonly query: (node: BinaryNode, timeoutMs: number) => Promise<BinaryNode>;
     readonly store: WaAppStateStore;
+    readonly getCurrentMeJid?: () => string | null | undefined;
     readonly hostDomain?: string;
     readonly defaultTimeoutMs?: number;
     readonly onMissingKeys?: (event: WaAppStateMissingKeysEvent) => Promise<void>;
@@ -20,6 +21,7 @@ export declare class WaAppStateSyncClient {
     private readonly logger;
     private readonly query;
     private readonly store;
+    private readonly getCurrentMeJid?;
     private readonly hostDomain;
     private readonly defaultTimeoutMs;
     private readonly onMissingKeys?;
@@ -33,13 +35,11 @@ export declare class WaAppStateSyncClient {
     sync(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;
     private syncOnce;
     private syncCollectionsRound;
-    private prepareSyncRoundRequest;
     private buildCollectionSyncRequest;
     private buildSyncIqNode;
     private fetchSyncPayloadByCollection;
     private processCollectionRound;
     private createCollectionOutcome;
-    private collectDistinctMissingKeyIds;
     private notifyMissingKeys;
     private resolveReadyPatches;
     private validateSnapshot;
@@ -51,9 +51,12 @@ export declare class WaAppStateSyncClient {
     private decryptPatchMutations;
     private assertPatchMacsMatch;
     private buildOutgoingPatch;
+    private resolveDeviceIndex;
+    private buildPatchClientDebugData;
     private computeNextCollectionState;
     private normalizeProtoLong;
     private groupPendingMutations;
+    private preloadKeyData;
     private getKeyData;
     private getCollectionState;
     private setCollectionState;

package/dist/types/appstate/constants.d.ts

@@ -11,4 +11,5 @@ export declare const APP_STATE_IV_LENGTH = 16;
 export declare const APP_STATE_LT_HASH_SIZE = 128;
 export declare const APP_STATE_POINT_SIZE = 2;
 export declare const APP_STATE_EMPTY_LT_HASH: Uint8Array<ArrayBuffer>;
+export declare const APP_STATE_DEFAULT_COLLECTION_VERSION = 0;
 export declare const APP_STATE_DEFAULT_COLLECTIONS: readonly AppStateCollectionName[];

package/dist/types/appstate/store/sqlite.d.ts

@@ -1,21 +1,7 @@
 import type { WaAppStateStoreData, WaAppStateSyncKey } from '../types';
-export interface AppStateSyncKeyRow extends Record<string, unknown> {
-    readonly key_id: unknown;
-    readonly key_data: unknown;
-    readonly timestamp: unknown;
-    readonly fingerprint: unknown;
-}
-export interface AppStateCollectionVersionRow extends Record<string, unknown> {
-    readonly collection: unknown;
-    readonly version: unknown;
-    readonly hash: unknown;
-}
-export interface AppStateCollectionValueRow extends Record<string, unknown> {
-    readonly collection: unknown;
-    readonly index_mac_hex: unknown;
-    readonly value_mac: unknown;
-}
+type SqliteRow = Readonly<Record<string, unknown>>;
 export declare function encodeAppStateFingerprint(fingerprint: WaAppStateSyncKey['fingerprint']): Uint8Array | null;
 export declare function decodeAppStateFingerprint(raw: unknown): WaAppStateSyncKey['fingerprint'] | undefined;
-export declare function decodeAppStateSyncKeys(rows: readonly AppStateSyncKeyRow[]): readonly WaAppStateSyncKey[];
-export declare function decodeAppStateCollections(versionRows: readonly AppStateCollectionVersionRow[], valueRows: readonly AppStateCollectionValueRow[]): WaAppStateStoreData['collections'];
+export declare function decodeAppStateSyncKeys(rows: readonly SqliteRow[]): readonly WaAppStateSyncKey[];
+export declare function decodeAppStateCollections(versionRows: readonly SqliteRow[], valueRows: readonly SqliteRow[]): WaAppStateStoreData['collections'];
+export {};

package/dist/types/appstate/utils.d.ts

@@ -1,7 +1,6 @@
 import type { AppStateCollectionName, WaAppStateSyncKey } from './types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { Proto } from '..';
-export declare function keyIdToHex(keyId: Uint8Array): string;
 export declare function parseCollectionName(value: string | undefined): AppStateCollectionName | null;
 export declare function keyDeviceId(keyId: Uint8Array): number | null;
 export declare function keyEpoch(keyId: Uint8Array): number;