zapo-js 0.1.0

package/dist/transport/noise/WaNoiseSession.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaNoiseSession = void 0;
+const _crypto_1 = require("../../crypto/index.js");
+const ConsoleLogger_1 = require("../../infra/log/ConsoleLogger");
+const BoundedTaskQueue_1 = require("../../infra/perf/BoundedTaskQueue");
+const _proto_1 = require("../../proto.js");
+const constants_1 = require("../../protocol/constants");
+const constants_2 = require("../noise/constants");
+const WaClientPayload_1 = require("../noise/WaClientPayload");
+const WaFrameCodec_1 = require("../noise/WaFrameCodec");
+const WaNoiseCert_1 = require("../noise/WaNoiseCert");
+const WaNoiseHandshake_1 = require("../noise/WaNoiseHandshake");
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
+function resolvePayload(payload) {
+    if (payload instanceof Uint8Array) {
+        return Promise.resolve(payload);
+    }
+    return Promise.resolve(payload()).then((value) => (0, bytes_1.toBytesView)(value));
+}
+async function resolveHandshakePayload(config) {
+    if (config.isRegistered) {
+        if (config.loginPayload) {
+            return resolvePayload(config.loginPayload);
+        }
+        if (config.loginPayloadConfig) {
+            return (0, WaClientPayload_1.buildLoginPayload)(config.loginPayloadConfig);
+        }
+        throw new Error('noise login payload is missing');
+    }
+    if (config.registrationPayload) {
+        return resolvePayload(config.registrationPayload);
+    }
+    if (config.registrationPayloadConfig) {
+        return (0, WaClientPayload_1.buildRegistrationPayload)(config.registrationPayloadConfig);
+    }
+    throw new Error('noise registration payload is missing');
+}
+function buildRoutingInfoPrefix(routingInfo) {
+    const prefix = new Uint8Array(2 + 2 + 1 + 2 + routingInfo.length);
+    prefix[0] = 0x45; // E
+    prefix[1] = 0x44; // D
+    prefix[2] = 0x00;
+    prefix[3] = 0x01;
+    prefix[4] = (routingInfo.length >> 16) & 0xff;
+    prefix[5] = (routingInfo.length >> 8) & 0xff;
+    prefix[6] = routingInfo.length & 0xff;
+    prefix.set(routingInfo, 7);
+    return prefix;
+}
+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.handshakeWaiter = null;
+        this.handshakeRejecter = null;
+        this.pendingDecryptedFrames = [];
+        this.closedError = null;
+        this.noiseSocket = null;
+        this.serverStaticKey = null;
+        this.handshakeFrameTimeoutMs = constants_1.WA_DEFAULTS.CONNECT_TIMEOUT_MS;
+    }
+    async start(config) {
+        this.reset();
+        this.logger.debug('noise session start', {
+            isRegistered: config.isRegistered,
+            hasServerStaticKey: !!config.serverStaticKey
+        });
+        const protocolHeader = config.protocolHeader
+            ? (0, bytes_1.toBytesView)(config.protocolHeader)
+            : constants_2.WA_PROTO_HEADER;
+        const introFrame = config.routingInfo && config.routingInfo.length > 0
+            ? (0, bytes_1.concatBytes)([buildRoutingInfoPrefix(config.routingInfo), protocolHeader])
+            : protocolHeader;
+        this.frameCodec = new WaFrameCodec_1.WaFrameCodec(introFrame);
+        const [ephemeralKeyPair, payload] = await Promise.all([
+            _crypto_1.X25519.generateKeyPair(),
+            resolveHandshakePayload(config)
+        ]);
+        const verifyCertificates = config.verifyCertificateChain !== false;
+        if (config.serverStaticKey && config.serverStaticKey.length === 32) {
+            this.logger.info('noise session attempting resume handshake (IK)');
+            this.noiseSocket = await this.resumeHandshake(config.serverStaticKey, config.clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates);
+            await this.decodeBufferedPostHandshakeFrames();
+            this.logger.info('noise session established via resume/full fallback path');
+            return;
+        }
+        this.logger.info('noise session starting full handshake (XX)');
+        this.noiseSocket = await this.fullHandshake(config.clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates);
+        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');
+        }
+        const encrypted = await this.writeQueue.enqueue(() => this.noiseSocket.encrypt(frame));
+        return this.frameCodec.encodeFrame(encrypted);
+    }
+    async pushWireChunk(chunk) {
+        const codec = this.frameCodec;
+        if (!codec) {
+            return [];
+        }
+        const out = [];
+        if (this.pendingDecryptedFrames.length > 0) {
+            out.push(...this.pendingDecryptedFrames);
+            this.pendingDecryptedFrames = [];
+        }
+        const frames = codec.pushWireChunk(chunk);
+        if (!this.noiseSocket) {
+            for (const frame of frames) {
+                const waiter = this.handshakeWaiter;
+                const rejecter = this.handshakeRejecter;
+                if (waiter && rejecter) {
+                    this.handshakeWaiter = null;
+                    this.handshakeRejecter = null;
+                    waiter(frame);
+                    continue;
+                }
+                this.handshakeInbox.push(frame);
+            }
+            return out;
+        }
+        for (const frame of frames) {
+            const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
+            out.push(decrypted);
+        }
+        return out;
+    }
+    onSocketClosed(error) {
+        const closeError = error ?? new Error('noise session socket closed');
+        this.logger.debug('noise session socket closed', { message: closeError.message });
+        this.closedError = closeError;
+        const rejecter = this.handshakeRejecter;
+        if (rejecter) {
+            this.handshakeRejecter = null;
+            this.handshakeWaiter = null;
+            rejecter(closeError);
+        }
+    }
+    reset() {
+        this.logger.trace('noise session reset');
+        this.frameCodec = null;
+        this.handshakeInbox = [];
+        this.handshakeWaiter = null;
+        this.handshakeRejecter = null;
+        this.pendingDecryptedFrames = [];
+        this.closedError = null;
+        this.noiseSocket = null;
+        this.serverStaticKey = null;
+    }
+    getServerStaticKey() {
+        if (!this.serverStaticKey) {
+            return null;
+        }
+        return this.serverStaticKey;
+    }
+    async fullHandshake(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates) {
+        this.logger.trace('noise full handshake: send client hello');
+        const handshake = new WaNoiseHandshake_1.WaNoiseHandshake();
+        await handshake.start(constants_2.NOISE_XX_NAME, protocolHeader);
+        await handshake.authenticate(ephemeralKeyPair.pubKey);
+        const clientHello = _proto_1.proto.HandshakeMessage.encode({
+            clientHello: {
+                ephemeral: ephemeralKeyPair.pubKey
+            }
+        }).finish();
+        const serverHello = await this.sendAndReceiveHandshakeFrame(clientHello);
+        return this.continueFullHandshake(handshake, serverHello, clientStaticKeyPair, ephemeralKeyPair, payload, verifyCertificates);
+    }
+    async resumeHandshake(serverStaticKey, clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates) {
+        const resumeResult = await this.tryResumeHandshakeWithIk(serverStaticKey, clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader);
+        if (resumeResult.socket) {
+            return resumeResult.socket;
+        }
+        this.logger.info('noise resume handshake fallback to XX');
+        return this.resumeHandshakeWithFallback(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, resumeResult.serverHelloFrame, verifyCertificates);
+    }
+    async tryResumeHandshakeWithIk(serverStaticKey, clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader) {
+        this.logger.trace('noise resume handshake: send IK client hello');
+        const handshake = new WaNoiseHandshake_1.WaNoiseHandshake();
+        await handshake.start(constants_2.NOISE_IK_NAME, protocolHeader);
+        await handshake.authenticate(serverStaticKey);
+        await handshake.authenticate(ephemeralKeyPair.pubKey);
+        const agreement1 = await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverStaticKey);
+        await handshake.mixIntoKey(agreement1);
+        const encryptedClientStatic = await handshake.encrypt(clientStaticKeyPair.pubKey);
+        const agreement2 = await _crypto_1.X25519.scalarMult(clientStaticKeyPair.privKey, serverStaticKey);
+        await handshake.mixIntoKey(agreement2);
+        const encryptedPayload = await handshake.encrypt(payload);
+        const clientHello = _proto_1.proto.HandshakeMessage.encode({
+            clientHello: {
+                ephemeral: ephemeralKeyPair.pubKey,
+                payload: encryptedPayload,
+                static: encryptedClientStatic
+            }
+        }).finish();
+        const serverHelloFrame = await this.sendAndReceiveHandshakeFrame(clientHello);
+        const parsed = _proto_1.proto.HandshakeMessage.decode(serverHelloFrame);
+        const serverHello = parsed.serverHello;
+        if (!serverHello) {
+            throw new Error('noise resume handshake missing serverHello');
+        }
+        if (serverHello.static) {
+            return { socket: null, serverHelloFrame };
+        }
+        if (!serverHello.ephemeral) {
+            throw new Error('noise resume handshake missing server ephemeral');
+        }
+        if (!serverHello.payload) {
+            throw new Error('noise resume handshake missing certificate payload');
+        }
+        const serverEphemeral = (0, bytes_1.toBytesView)(serverHello.ephemeral);
+        await handshake.authenticate(serverEphemeral);
+        await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral));
+        await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral));
+        await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.payload));
+        this.serverStaticKey = serverStaticKey;
+        this.logger.info('noise resume handshake successful without fallback');
+        return { socket: await handshake.finish(), serverHelloFrame: null };
+    }
+    async resumeHandshakeWithFallback(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, serverHelloFrame, verifyCertificates) {
+        const fallback = new WaNoiseHandshake_1.WaNoiseHandshake();
+        await fallback.start(constants_2.NOISE_XX_FALLBACK_NAME, protocolHeader);
+        await fallback.authenticate(ephemeralKeyPair.pubKey);
+        return this.continueFullHandshake(fallback, serverHelloFrame, clientStaticKeyPair, ephemeralKeyPair, payload, verifyCertificates);
+    }
+    async continueFullHandshake(handshake, serverHelloFrame, clientStaticKeyPair, ephemeralKeyPair, payload, verifyCertificates) {
+        this.logger.trace('noise continue full handshake');
+        const parsed = _proto_1.proto.HandshakeMessage.decode(serverHelloFrame);
+        const serverHello = parsed.serverHello;
+        if (!serverHello?.ephemeral || !serverHello.static || !serverHello.payload) {
+            throw new Error('noise full handshake missing server hello fields');
+        }
+        const serverEphemeral = (0, bytes_1.toBytesView)(serverHello.ephemeral);
+        await handshake.authenticate(serverEphemeral);
+        await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral));
+        const serverStatic = await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.static));
+        await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverStatic));
+        const certificate = await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.payload));
+        if (verifyCertificates) {
+            await (0, WaNoiseCert_1.verifyNoiseCertificateChain)(certificate, serverStatic);
+            this.logger.trace('noise certificate chain verified');
+        }
+        this.serverStaticKey = serverStatic;
+        const encryptedClientStatic = await handshake.encrypt(clientStaticKeyPair.pubKey);
+        await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral));
+        const encryptedPayload = await handshake.encrypt(payload);
+        const clientFinish = _proto_1.proto.HandshakeMessage.encode({
+            clientFinish: {
+                static: encryptedClientStatic,
+                payload: encryptedPayload
+            }
+        }).finish();
+        await this.sendHandshakeFrame(clientFinish);
+        this.logger.trace('noise full handshake client finish sent');
+        return handshake.finish();
+    }
+    async sendHandshakeFrame(frame) {
+        const codec = this.frameCodec;
+        if (!codec) {
+            throw new Error('noise frame codec is not initialized');
+        }
+        this.logger.trace('noise send handshake frame', { byteLength: frame.byteLength });
+        await this.sendWire(codec.encodeFrame(frame));
+    }
+    async sendAndReceiveHandshakeFrame(frame) {
+        await this.sendHandshakeFrame(frame);
+        return this.waitHandshakeFrame();
+    }
+    async waitHandshakeFrame() {
+        if (this.closedError) {
+            throw this.closedError;
+        }
+        const queued = this.handshakeInbox.shift();
+        if (queued) {
+            this.logger.trace('noise handshake frame consumed from queue');
+            return queued;
+        }
+        this.logger.trace('noise waiting handshake frame');
+        return new Promise((resolve, reject) => {
+            if (this.closedError) {
+                reject(this.closedError);
+                return;
+            }
+            const timeout = setTimeout(() => {
+                if (this.handshakeWaiter === resolve) {
+                    this.handshakeWaiter = null;
+                    this.handshakeRejecter = null;
+                }
+                reject(new Error(`noise handshake frame timeout after ${this.handshakeFrameTimeoutMs}ms`));
+            }, this.handshakeFrameTimeoutMs);
+            timeout.unref?.();
+            this.handshakeWaiter = (frame) => {
+                clearTimeout(timeout);
+                resolve(frame);
+            };
+            this.handshakeRejecter = (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            };
+        }).catch((error) => {
+            throw (0, primitives_1.toError)(error);
+        });
+    }
+    async decodeBufferedPostHandshakeFrames() {
+        if (!this.noiseSocket || this.handshakeInbox.length === 0) {
+            return;
+        }
+        this.logger.debug('decoding buffered post-handshake frames', {
+            count: this.handshakeInbox.length
+        });
+        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);
+        }
+    }
+}
+exports.WaNoiseSession = WaNoiseSession;

package/dist/transport/noise/WaNoiseSocket.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaNoiseSocket = void 0;
+const _crypto_1 = require("../../crypto/index.js");
+class WaNoiseSocket {
+    constructor(encryptKey, decryptKey) {
+        this.encryptKey = encryptKey;
+        this.decryptKey = decryptKey;
+        this.writeCounter = 0;
+        this.readCounter = 0;
+    }
+    async encrypt(frame, additionalData) {
+        const nonce = (0, _crypto_1.buildNonce)(this.writeCounter++);
+        return (0, _crypto_1.aesGcmEncrypt)(this.encryptKey, nonce, frame, additionalData);
+    }
+    async decrypt(frame, additionalData) {
+        const nonce = (0, _crypto_1.buildNonce)(this.readCounter++);
+        return (0, _crypto_1.aesGcmDecrypt)(this.decryptKey, nonce, frame, additionalData);
+    }
+}
+exports.WaNoiseSocket = WaNoiseSocket;

package/dist/transport/noise/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_CA_PUBLIC_KEY_HEX = exports.ROOT_CA_SERIAL = exports.NOISE_XX_FALLBACK_NAME = exports.NOISE_IK_NAME = exports.NOISE_XX_NAME = exports.WA_PROTO_HEADER = exports.DEFAULT_VERSION_BASE = void 0;
+const bytes_1 = require("../../util/bytes");
+exports.DEFAULT_VERSION_BASE = '2.3000.1034748654';
+exports.WA_PROTO_HEADER = new Uint8Array([87, 65, 6, 3]);
+exports.NOISE_XX_NAME = bytes_1.TEXT_ENCODER.encode('Noise_XX_25519_AESGCM_SHA256\0\0\0\0');
+exports.NOISE_IK_NAME = bytes_1.TEXT_ENCODER.encode('Noise_IK_25519_AESGCM_SHA256\0\0\0\0');
+exports.NOISE_XX_FALLBACK_NAME = bytes_1.TEXT_ENCODER.encode('Noise_XXfallback_25519_AESGCM_SHA256');
+exports.ROOT_CA_SERIAL = 0;
+exports.ROOT_CA_PUBLIC_KEY_HEX = '142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b';

package/dist/transport/noise/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/transport/stream/parse.js

@@ -0,0 +1,97 @@
+"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;
+}
+function parseStreamControlNode(node) {
+    if (node.tag === constants_1.WA_STREAM_SIGNALING.XML_STREAM_END_TAG) {
+        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'
+        };
+    }
+    const codeRaw = node.attrs.code;
+    if (codeRaw) {
+        const code = parseStrictUnsignedInt(codeRaw);
+        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
+        };
+    }
+    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 parseStrictUnsignedInt(value);
+}
+function parseCompanionEncStatic(value, onError) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        return (0, base64_1.base64ToBytes)(value, 'success.companion_enc_static');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            onError?.(error);
+        }
+        return undefined;
+    }
+}
+function parseSuccessPersistAttributes(node, onCompanionParseError) {
+    return {
+        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),
+        connectionLocation: node.attrs.location,
+        accountCreationTs: parseOptionalInt(node.attrs.creation)
+    };
+}

package/dist/transport/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,59 @@
+import type { Proto } from '..';
+interface WaAppStateDerivedKeys {
+    readonly indexKey: Uint8Array;
+    readonly valueEncryptionKey: Uint8Array;
+    readonly valueMacKey: Uint8Array;
+    readonly snapshotMacKey: Uint8Array;
+    readonly patchMacKey: Uint8Array;
+}
+interface WaAppStateEncryptedMutation {
+    readonly indexMac: Uint8Array;
+    readonly valueBlob: Uint8Array;
+    readonly valueMac: Uint8Array;
+}
+interface WaAppStateDecryptedMutation {
+    readonly index: string;
+    readonly value: Proto.ISyncActionValue | null;
+    readonly version: number;
+    readonly indexMac: Uint8Array;
+    readonly valueMac: Uint8Array;
+}
+export declare class WaAppStateCrypto {
+    private readonly derivedKeysCache;
+    private readonly derivedKeysCacheMaxSize;
+    constructor(derivedKeysCacheMaxSize?: number);
+    clearCache(): void;
+    deriveKeys(keyData: Uint8Array): Promise<WaAppStateDerivedKeys>;
+    generateIndexMac(indexKey: Uint8Array, indexBytes: Uint8Array): Promise<Uint8Array>;
+    encryptMutation(args: {
+        readonly operation: number;
+        readonly keyId: Uint8Array;
+        readonly keyData: Uint8Array;
+        readonly index: string;
+        readonly value: Proto.ISyncActionValue | null;
+        readonly version: number;
+        readonly iv?: Uint8Array;
+    }): Promise<WaAppStateEncryptedMutation>;
+    decryptMutation(args: {
+        readonly operation: number;
+        readonly keyId: Uint8Array;
+        readonly keyData: Uint8Array;
+        readonly indexMac: Uint8Array;
+        readonly valueBlob: Uint8Array;
+    }): Promise<WaAppStateDecryptedMutation>;
+    generateSnapshotMac(keyData: Uint8Array, ltHash: Uint8Array, version: number, collectionName: string): Promise<Uint8Array>;
+    generatePatchMac(keyData: Uint8Array, snapshotMac: Uint8Array, valueMacs: readonly Uint8Array[], version: number, collectionName: string): Promise<Uint8Array>;
+    ltHashAdd(base: Uint8Array, addValues: readonly Uint8Array[]): Promise<Uint8Array>;
+    ltHashSubtract(base: Uint8Array, removeValues: readonly Uint8Array[]): Promise<Uint8Array>;
+    ltHashSubtractThenAdd(base: Uint8Array, addValues: readonly Uint8Array[], removeValues: readonly Uint8Array[]): Promise<{
+        readonly hash: Uint8Array;
+        readonly subtractResult: Uint8Array;
+    }>;
+    private ltHashApply;
+    private pointwiseWithOverflow;
+    private generateAssociatedData;
+    private generateValueMac;
+    private normalizeDerivedKeysCacheMaxSize;
+    private touchDerivedKeysCacheEntry;
+}
+export {};

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

@@ -0,0 +1,63 @@
+import type { AppStateCollectionName, WaAppStateMissingKeysEvent, WaAppStateSyncOptions, WaAppStateStoreData, WaAppStateSyncResult, WaAppStateSyncKey } from './types';
+import type { Logger } from '../infra/log/types';
+import type { Proto } from '..';
+import type { WaAppStateStore } from '../store/contracts/appstate.store';
+import type { BinaryNode } from '../transport/types';
+interface WaAppStateSyncClientOptions {
+    readonly logger: Logger;
+    readonly query: (node: BinaryNode, timeoutMs: number) => Promise<BinaryNode>;
+    readonly store: WaAppStateStore;
+    readonly hostDomain?: string;
+    readonly defaultTimeoutMs?: number;
+    readonly onMissingKeys?: (event: WaAppStateMissingKeysEvent) => Promise<void>;
+}
+export declare class WaAppStateMissingKeyError extends Error {
+    readonly keyId: Uint8Array | null;
+    readonly collection: AppStateCollectionName;
+    constructor(message: string, keyId: Uint8Array | null, collection: AppStateCollectionName);
+}
+export declare class WaAppStateSyncClient {
+    private readonly logger;
+    private readonly query;
+    private readonly store;
+    private readonly hostDomain;
+    private readonly defaultTimeoutMs;
+    private readonly onMissingKeys?;
+    private readonly crypto;
+    private syncContext;
+    private syncPromise;
+    constructor(options: WaAppStateSyncClientOptions);
+    exportState(): Promise<WaAppStateStoreData>;
+    importSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
+    importSyncKeyShare(share: Proto.Message.IAppStateSyncKeyShare): Promise<number>;
+    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;
+    private parseCollectionPatchVersion;
+    private validatePatch;
+    private applySnapshot;
+    private applyPatch;
+    private decryptSnapshotRecords;
+    private decryptPatchMutations;
+    private assertPatchMacsMatch;
+    private buildOutgoingPatch;
+    private computeNextCollectionState;
+    private normalizeProtoLong;
+    private groupPendingMutations;
+    private getKeyData;
+    private getCollectionState;
+    private setCollectionState;
+    private persistCollectionUpdates;
+    private requireSyncContext;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import type { AppStateCollectionName, AppStateCollectionState } from './types';
+import type { Proto } from '..';
+import type { BinaryNode } from '../transport/types';
+export interface CollectionResponsePayload {
+    readonly collection: AppStateCollectionName;
+    readonly state: AppStateCollectionState;
+    readonly version?: number;
+    readonly patches: readonly Proto.ISyncdPatch[];
+    readonly snapshotReference?: Proto.IExternalBlobReference;
+}
+export declare function parseSyncResponse(iqNode: BinaryNode): readonly CollectionResponsePayload[];
+export declare function parseCollectionState(node: BinaryNode): AppStateCollectionState;

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

@@ -0,0 +1,14 @@
+import type { AppStateCollectionName } from './types';
+export declare const APP_STATE_DERIVED_KEY_LENGTH = 160;
+export declare const APP_STATE_DERIVED_INDEX_KEY_END = 32;
+export declare const APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END = 64;
+export declare const APP_STATE_DERIVED_VALUE_MAC_KEY_END = 96;
+export declare const APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END = 128;
+export declare const APP_STATE_DERIVED_PATCH_MAC_KEY_END = 160;
+export declare const APP_STATE_VALUE_MAC_LENGTH = 32;
+export declare const APP_STATE_MAC_OCTET_LENGTH = 8;
+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_COLLECTIONS: readonly AppStateCollectionName[];

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

@@ -0,0 +1,7 @@
+export * from './constants';
+export type { WaAppStateSyncOptions } from './types';
+export * from './utils';
+export { WaAppStateCrypto } from './WaAppStateCrypto';
+export { WaAppStateMissingKeyError } from './WaAppStateSyncClient';
+export { parseCollectionState, parseSyncResponse, type CollectionResponsePayload } from './WaAppStateSyncResponseParser';
+export { WaAppStateSyncClient } from './WaAppStateSyncClient';

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

@@ -0,0 +1,21 @@
+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;
+}
+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'];