zapo-js 0.1.0 → 0.1.2

package/dist/signal/session/resolver.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignalSessionResolver = createSignalSessionResolver;
+const keys_1 = require("../../crypto/core/keys");
+const jid_1 = require("../../protocol/jid");
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
+function createSignalSessionResolver(options) {
+    const { signalProtocol, signalStore, signalIdentitySync, signalSessionSync, logger } = options;
+    const ensureSession = async (address, jid, expectedIdentity, reasonIdentity = false) => {
+        const expectedSerializedIdentity = expectedIdentity
+            ? (0, keys_1.toSerializedPubKey)(expectedIdentity)
+            : null;
+        if (reasonIdentity) {
+            await signalIdentitySync.syncIdentityKeys([jid]);
+        }
+        if (await signalProtocol.hasSession(address)) {
+            if (expectedSerializedIdentity) {
+                const storedIdentity = await signalStore.getRemoteIdentity(address);
+                if (!storedIdentity || !(0, bytes_1.uint8Equal)(storedIdentity, expectedSerializedIdentity)) {
+                    throw new Error('identity mismatch');
+                }
+            }
+            return;
+        }
+        logger.info('signal session missing, fetching remote key bundle', { jid });
+        const fetched = await signalSessionSync.fetchKeyBundle({
+            jid,
+            reasonIdentity
+        });
+        const remoteIdentity = (0, keys_1.toSerializedPubKey)(fetched.bundle.identity);
+        if (reasonIdentity) {
+            const storedIdentity = await signalStore.getRemoteIdentity(address);
+            if (storedIdentity && !(0, bytes_1.uint8Equal)(remoteIdentity, storedIdentity)) {
+                throw new Error('identity mismatch');
+            }
+        }
+        if (expectedSerializedIdentity && !(0, bytes_1.uint8Equal)(remoteIdentity, expectedSerializedIdentity)) {
+            throw new Error('identity mismatch');
+        }
+        await signalProtocol.establishOutgoingSession(address, fetched.bundle);
+        logger.info('signal session synchronized', {
+            jid,
+            regId: fetched.bundle.regId,
+            hasOneTimeKey: fetched.bundle.oneTimeKey !== undefined
+        });
+    };
+    const ensureSessionsBatch = async (targetJids, expectedIdentityByJid) => {
+        const seenTargetJids = new Set();
+        const normalizedTargetJids = [];
+        const normalizedTargetAddresses = [];
+        for (let index = 0; index < targetJids.length; index += 1) {
+            const jid = (0, jid_1.normalizeDeviceJid)(targetJids[index]);
+            if (seenTargetJids.has(jid)) {
+                continue;
+            }
+            seenTargetJids.add(jid);
+            normalizedTargetJids.push(jid);
+            normalizedTargetAddresses.push((0, jid_1.parseSignalAddressFromJid)(jid));
+        }
+        if (normalizedTargetJids.length === 0) {
+            return;
+        }
+        const normalizedExpectedIdentityByJid = expectedIdentityByJid && expectedIdentityByJid.size > 0
+            ? new Map()
+            : undefined;
+        if (normalizedExpectedIdentityByJid && expectedIdentityByJid) {
+            for (const [jid, identity] of expectedIdentityByJid.entries()) {
+                try {
+                    normalizedExpectedIdentityByJid.set((0, jid_1.normalizeDeviceJid)(jid), identity);
+                }
+                catch (error) {
+                    logger.trace('ignoring malformed expected identity jid during batch normalization', { jid, message: (0, primitives_1.toError)(error).message });
+                }
+            }
+        }
+        const hasSessions = await signalProtocol.hasSessions(normalizedTargetAddresses);
+        if (normalizedExpectedIdentityByJid) {
+            const identityAddresses = [];
+            const expectedSerializedIdentities = [];
+            for (let index = 0; index < normalizedTargetJids.length; index += 1) {
+                if (!hasSessions[index]) {
+                    continue;
+                }
+                const expectedIdentity = normalizedExpectedIdentityByJid.get(normalizedTargetJids[index]);
+                if (!expectedIdentity) {
+                    continue;
+                }
+                identityAddresses.push(normalizedTargetAddresses[index]);
+                expectedSerializedIdentities.push((0, keys_1.toSerializedPubKey)(expectedIdentity));
+            }
+            const storedIdentities = await signalStore.getRemoteIdentities(identityAddresses);
+            for (let index = 0; index < storedIdentities.length; index += 1) {
+                const storedIdentity = storedIdentities[index];
+                if (!storedIdentity ||
+                    !(0, bytes_1.uint8Equal)(storedIdentity, expectedSerializedIdentities[index])) {
+                    throw new Error('identity mismatch');
+                }
+            }
+        }
+        const missingIndices = [];
+        for (let index = 0; index < normalizedTargetJids.length; index += 1) {
+            if (!hasSessions[index]) {
+                missingIndices.push(index);
+            }
+        }
+        if (missingIndices.length === 0) {
+            return;
+        }
+        try {
+            const batchRequest = [];
+            for (let index = 0; index < missingIndices.length; index += 1) {
+                batchRequest.push({ jid: normalizedTargetJids[missingIndices[index]] });
+            }
+            const batchResults = await signalSessionSync.fetchKeyBundles(batchRequest);
+            const fallbackIndices = [];
+            const establishedIndices = [];
+            const establishPromises = [];
+            for (let index = 0; index < missingIndices.length; index += 1) {
+                const targetIndex = missingIndices[index];
+                const result = batchResults[index];
+                if (!result || !('bundle' in result)) {
+                    fallbackIndices.push(targetIndex);
+                    continue;
+                }
+                const targetJid = normalizedTargetJids[targetIndex];
+                const expectedIdentity = normalizedExpectedIdentityByJid?.get(targetJid);
+                const remoteIdentity = (0, keys_1.toSerializedPubKey)(result.bundle.identity);
+                if (expectedIdentity &&
+                    !(0, bytes_1.uint8Equal)(remoteIdentity, (0, keys_1.toSerializedPubKey)(expectedIdentity))) {
+                    throw new Error('identity mismatch');
+                }
+                establishedIndices.push(targetIndex);
+                establishPromises.push(signalProtocol
+                    .establishOutgoingSession(normalizedTargetAddresses[targetIndex], result.bundle)
+                    .then(() => {
+                    logger.debug('signal session synchronized from batch key fetch', {
+                        jid: targetJid,
+                        regId: result.bundle.regId,
+                        hasOneTimeKey: result.bundle.oneTimeKey !== undefined
+                    });
+                }));
+            }
+            const establishmentResults = await Promise.allSettled(establishPromises);
+            for (let index = 0; index < establishmentResults.length; index += 1) {
+                const result = establishmentResults[index];
+                if (result.status === 'fulfilled') {
+                    continue;
+                }
+                const error = (0, primitives_1.toError)(result.reason);
+                if (error.message === 'identity mismatch') {
+                    throw error;
+                }
+                fallbackIndices.push(establishedIndices[index]);
+            }
+            if (fallbackIndices.length === 0) {
+                return;
+            }
+            logger.warn('signal batch key fetch returned partial errors, falling back to single requests', {
+                requested: missingIndices.length,
+                fallbackTargets: fallbackIndices.length
+            });
+            for (let index = 0; index < fallbackIndices.length; index += 1) {
+                const targetIndex = fallbackIndices[index];
+                const jid = normalizedTargetJids[targetIndex];
+                await ensureSession(normalizedTargetAddresses[targetIndex], jid, normalizedExpectedIdentityByJid?.get(jid));
+            }
+        }
+        catch (error) {
+            const normalized = (0, primitives_1.toError)(error);
+            if (normalized.message === 'identity mismatch') {
+                throw normalized;
+            }
+            logger.warn('signal batch key fetch failed, falling back to single requests', {
+                requested: missingIndices.length,
+                message: normalized.message
+            });
+            for (let index = 0; index < missingIndices.length; index += 1) {
+                const targetIndex = missingIndices[index];
+                const jid = normalizedTargetJids[targetIndex];
+                await ensureSession(normalizedTargetAddresses[targetIndex], jid, normalizedExpectedIdentityByJid?.get(jid));
+            }
+        }
+    };
+    return {
+        ensureSession,
+        ensureSessionsBatch
+    };
+}

package/dist/signal/store/sqlite.js

@@ -14,6 +14,7 @@ exports.decodeSqliteCount = decodeSqliteCount;
 exports.decodeSignalRemoteIdentity = decodeSignalRemoteIdentity;
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../../protocol/constants");
+const bytes_1 = require("../../util/bytes");
 const coercion_1 = require("../../util/coercion");
 function toSignalAddressParts(address) {
     return {
@@ -108,17 +109,11 @@ function encodeSignalRecvChain(chain) {
 }
 function decodeSignalMessageKey(messageKey, field) {
     const cipherKey = (0, coercion_1.asBytes)(messageKey.cipherKey, `${field}.cipherKey`);
-    if (cipherKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(cipherKey, 32, `invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
     const macKey = (0, coercion_1.asBytes)(messageKey.macKey, `${field}.macKey`);
-    if (macKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.macKey length ${macKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(macKey, 32, `invalid ${field}.macKey length ${macKey.byteLength}`);
     const iv = (0, coercion_1.asBytes)(messageKey.iv, `${field}.iv`);
-    if (iv.byteLength !== 16) {
-        throw new Error(`invalid ${field}.iv length ${iv.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(iv, 16, `invalid ${field}.iv length ${iv.byteLength}`);
     return {
         index: (0, coercion_1.asNumber)(messageKey.index, `${field}.index`),
         cipherKey,
@@ -132,13 +127,9 @@ function decodeSignalRecvChain(chain, field) {
         throw new Error(`missing ${field}.chainKey`);
     }
     const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    if (ratchetPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
     const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
-    if (chainKeyBytes.byteLength !== 32) {
-        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
     return {
         ratchetPubKey,
         nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
@@ -155,17 +146,11 @@ function decodeSignalSendChain(chain, field) {
     if (!privateKey) {
         throw new Error(`missing ${field}.senderRatchetKeyPrivate`);
     }
-    if (privateKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
     const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    if (ratchetPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
     const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
-    if (chainKeyBytes.byteLength !== 32) {
-        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
     return {
         ratchetKey: {
             pubKey: ratchetPubKey,
@@ -182,26 +167,20 @@ function decodeSignalSessionSnapshot(session, field) {
     }
     const pendingPreKey = session.pendingPreKey;
     const localPubKey = (0, coercion_1.asBytes)(session.localIdentityPublic, `${field}.localIdentityPublic`);
-    if (localPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(localPubKey, 33, `invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
     const remotePubKey = (0, coercion_1.asBytes)(session.remoteIdentityPublic, `${field}.remoteIdentityPublic`);
-    if (remotePubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(remotePubKey, 33, `invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
     const rootKey = (0, coercion_1.asBytes)(session.rootKey, `${field}.rootKey`);
-    if (rootKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.rootKey length ${rootKey.byteLength}`);
-    }
+    (0, bytes_1.assertByteLength)(rootKey, 32, `invalid ${field}.rootKey length ${rootKey.byteLength}`);
     const localOneTimePubKey = pendingPreKey
         ? (0, coercion_1.asBytes)(pendingPreKey.baseKey, `${field}.pendingPreKey.baseKey`)
         : null;
-    if (localOneTimePubKey && localOneTimePubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
+    if (localOneTimePubKey) {
+        (0, bytes_1.assertByteLength)(localOneTimePubKey, 33, `invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
     }
     const aliceBaseKey = (0, coercion_1.asOptionalBytes)(session.aliceBaseKey, `${field}.aliceBaseKey`) ?? null;
-    if (aliceBaseKey && aliceBaseKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
+    if (aliceBaseKey) {
+        (0, bytes_1.assertByteLength)(aliceBaseKey, 33, `invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
     }
     return {
         local: {

package/dist/store/createStore.js

@@ -104,18 +104,17 @@ function createStore(options) {
             if (cached) {
                 return cached;
             }
-            const custom = options.custom;
-            const customCache = options.customCache;
-            const customAuth = resolveStoreValue(normalizedSessionId, custom?.auth, 'custom.auth');
-            const customSignal = resolveStoreValue(normalizedSessionId, custom?.signal, 'custom.signal');
-            const customSenderKey = resolveStoreValue(normalizedSessionId, custom?.senderKey, 'custom.senderKey');
-            const customAppState = resolveStoreValue(normalizedSessionId, custom?.appState, 'custom.appState');
-            const customRetry = resolveStoreValue(normalizedSessionId, customCache?.retry, 'customCache.retry');
-            const customParticipants = resolveStoreValue(normalizedSessionId, customCache?.participants, 'customCache.participants');
-            const customDeviceList = resolveStoreValue(normalizedSessionId, customCache?.deviceList, 'customCache.deviceList');
-            const customMessages = resolveStoreValue(normalizedSessionId, custom?.messages, 'custom.messages');
-            const customThreads = resolveStoreValue(normalizedSessionId, custom?.threads, 'custom.threads');
-            const customContacts = resolveStoreValue(normalizedSessionId, custom?.contacts, 'custom.contacts');
+            const resolveCustom = (value, domainPath) => resolveStoreValue(normalizedSessionId, value, domainPath);
+            const customAuth = resolveCustom(options.custom?.auth, 'custom.auth');
+            const customSignal = resolveCustom(options.custom?.signal, 'custom.signal');
+            const customSenderKey = resolveCustom(options.custom?.senderKey, 'custom.senderKey');
+            const customAppState = resolveCustom(options.custom?.appState, 'custom.appState');
+            const customRetry = resolveCustom(options.customCache?.retry, 'customCache.retry');
+            const customParticipants = resolveCustom(options.customCache?.participants, 'customCache.participants');
+            const customDeviceList = resolveCustom(options.customCache?.deviceList, 'customCache.deviceList');
+            const customMessages = resolveCustom(options.custom?.messages, 'custom.messages');
+            const customThreads = resolveCustom(options.custom?.threads, 'custom.threads');
+            const customContacts = resolveCustom(options.custom?.contacts, 'custom.contacts');
             const memoryLimits = options.memory?.limits ?? {};
             const requiresSqlite = !customAuth ||
                 (!customSignal && providers.signal === 'sqlite') ||
@@ -136,7 +135,8 @@ function createStore(options) {
                     path: sqlite.path,
                     sessionId: normalizedSessionId,
                     driver: sqlite.driver ?? 'auto',
-                    pragmas: sqlite.pragmas
+                    pragmas: sqlite.pragmas,
+                    tableNames: sqlite.tableNames
                 }
                 : null;
             const authStore = customAuth ?? new auth_store_1.WaAuthSqliteStore(sqliteOptions);
@@ -261,8 +261,7 @@ function createStore(options) {
             return session;
         },
         async destroyCaches() {
-            const activeSessions = [...sessions.values()];
-            for (const session of activeSessions) {
+            for (const session of sessions.values()) {
                 await session.destroyCaches();
             }
         },
@@ -271,9 +270,8 @@ function createStore(options) {
                 return;
             }
             storeDestroyed = true;
-            const activeSessions = [...sessions.values()];
-            sessions.clear();
-            for (const session of activeSessions) {
+            for (const [sessionId, session] of sessions) {
+                sessions.delete(sessionId);
                 await session.destroy();
             }
         }

package/dist/store/noop.store.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOOP_DEVICE_LIST_STORE = exports.NOOP_PARTICIPANTS_STORE = exports.NOOP_CONTACT_STORE = exports.NOOP_THREAD_STORE = exports.NOOP_MESSAGE_STORE = void 0;
 const EMPTY_STORE_LIST = Object.freeze([]);
-const DEFAULT_PARTICIPANTS_CACHE_TTL_MS = 5 * 60 * 1000;
-const DEFAULT_DEVICE_LIST_CACHE_TTL_MS = 5 * 60 * 1000;
 exports.NOOP_MESSAGE_STORE = Object.freeze({
     upsert: async (_record) => { },
+    upsertBatch: async (_records) => { },
     getById: async (_id) => null,
     listByThread: async (_threadJid, _limit, _beforeTimestampMs) => EMPTY_STORE_LIST,
     deleteById: async (_id) => 0,
@@ -13,6 +12,7 @@ exports.NOOP_MESSAGE_STORE = Object.freeze({
 });
 exports.NOOP_THREAD_STORE = Object.freeze({
     upsert: async (_record) => { },
+    upsertBatch: async (_records) => { },
     getByJid: async (_jid) => null,
     list: async (_limit) => EMPTY_STORE_LIST,
     deleteByJid: async (_jid) => 0,
@@ -20,12 +20,12 @@ exports.NOOP_THREAD_STORE = Object.freeze({
 });
 exports.NOOP_CONTACT_STORE = Object.freeze({
     upsert: async (_record) => { },
+    upsertBatch: async (_records) => { },
     getByJid: async (_jid) => null,
     deleteByJid: async (_jid) => 0,
     clear: async () => { }
 });
 exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
-    getTtlMs: () => DEFAULT_PARTICIPANTS_CACHE_TTL_MS,
     upsertGroupParticipants: async (_snapshot) => { },
     getGroupParticipants: async (_groupJid, _nowMs) => null,
     deleteGroupParticipants: async (_groupJid) => 0,
@@ -34,10 +34,7 @@ exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
     destroy: async () => { }
 });
 exports.NOOP_DEVICE_LIST_STORE = Object.freeze({
-    getTtlMs: () => DEFAULT_DEVICE_LIST_CACHE_TTL_MS,
-    upsertUserDevices: async (_snapshot) => { },
     upsertUserDevicesBatch: async (_snapshots) => { },
-    getUserDevices: async (_userJid, _nowMs) => null,
     getUserDevicesBatch: async (userJids, _nowMs) => userJids.map(() => null),
     deleteUserDevices: async (_userJid) => 0,
     cleanupExpired: async (_nowMs) => 0,

package/dist/store/providers/memory/appstate.store.js

@@ -25,13 +25,14 @@ class WaAppStateMemoryStore {
         this.maxCollectionEntries = (0, coercion_1.resolvePositive)(options.maxCollectionEntries, DEFAULT_APPSTATE_MEMORY_STORE_LIMITS.collectionEntries, 'WaAppStateMemoryStoreOptions.maxCollectionEntries');
         if (initial) {
             for (const key of initial.keys) {
-                (0, collections_1.setBoundedMapEntry)(this.keys, (0, utils_1.keyIdToHex)(key.keyId), key, this.maxSyncKeys);
+                (0, collections_1.setBoundedMapEntry)(this.keys, (0, bytes_1.bytesToHex)(key.keyId), key, this.maxSyncKeys);
             }
             for (const [collectionName, collection] of Object.entries(initial.collections)) {
                 if (!collection) {
                     continue;
                 }
                 this.collections.set(collectionName, {
+                    initialized: true,
                     version: collection.version,
                     hash: collection.hash,
                     indexValueMap: toBoundedMap(Object.entries(collection.indexValueMap), this.maxCollectionEntries)
@@ -57,7 +58,7 @@ class WaAppStateMemoryStore {
     async upsertSyncKeys(keys) {
         let inserted = 0;
         for (const key of keys) {
-            const keyHex = (0, utils_1.keyIdToHex)(key.keyId);
+            const keyHex = (0, bytes_1.bytesToHex)(key.keyId);
             const existing = this.keys.get(keyHex);
             if (existing && (0, bytes_1.uint8Equal)(existing.keyData, key.keyData)) {
                 continue;
@@ -68,10 +69,13 @@ class WaAppStateMemoryStore {
         return inserted;
     }
     async getSyncKey(keyId) {
-        return this.keys.get((0, utils_1.keyIdToHex)(keyId)) ?? null;
+        return this.keys.get((0, bytes_1.bytesToHex)(keyId)) ?? null;
     }
     async getSyncKeyData(keyId) {
-        return this.keys.get((0, utils_1.keyIdToHex)(keyId))?.keyData ?? null;
+        return this.keys.get((0, bytes_1.bytesToHex)(keyId))?.keyData ?? null;
+    }
+    async getSyncKeyDataBatch(keyIds) {
+        return keyIds.map((keyId) => this.keys.get((0, bytes_1.bytesToHex)(keyId))?.keyData ?? null);
     }
     async getActiveSyncKey() {
         return (0, utils_1.pickActiveSyncKey)(this.keys.values());
@@ -80,6 +84,7 @@ class WaAppStateMemoryStore {
         let state = this.collections.get(collection);
         if (!state) {
             state = {
+                initialized: false,
                 version: 0,
                 hash: constants_1.APP_STATE_EMPTY_LT_HASH,
                 indexValueMap: new Map()
@@ -88,9 +93,28 @@ class WaAppStateMemoryStore {
         }
         return state;
     }
+    async getCollectionStates(collections) {
+        const result = new Array(collections.length);
+        for (let index = 0; index < collections.length; index += 1) {
+            const collection = collections[index];
+            let state = this.collections.get(collection);
+            if (!state) {
+                state = {
+                    initialized: false,
+                    version: 0,
+                    hash: constants_1.APP_STATE_EMPTY_LT_HASH,
+                    indexValueMap: new Map()
+                };
+                this.collections.set(collection, state);
+            }
+            result[index] = state;
+        }
+        return result;
+    }
     async setCollectionStates(updates) {
         for (const update of updates) {
             this.collections.set(update.collection, {
+                initialized: true,
                 version: update.version,
                 hash: update.hash,
                 indexValueMap: toBoundedMap(update.indexValueMap.entries(), this.maxCollectionEntries)

package/dist/store/providers/memory/contact.store.js

@@ -14,6 +14,11 @@ class WaContactMemoryStore {
     async upsert(record) {
         (0, collections_1.setBoundedMapEntry)(this.contacts, record.jid, record, this.maxContacts);
     }
+    async upsertBatch(records) {
+        for (const record of records) {
+            (0, collections_1.setBoundedMapEntry)(this.contacts, record.jid, record, this.maxContacts);
+        }
+    }
     async getByJid(jid) {
         return this.contacts.get(jid) ?? null;
     }

package/dist/store/providers/memory/device-list.store.js

@@ -17,38 +17,15 @@ class WaDeviceListMemoryStore {
         }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
         this.cleanupTimer.unref();
     }
-    getTtlMs() {
-        return this.ttlMs;
-    }
-    async upsertUserDevices(snapshot) {
-        (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
-            ...snapshot,
-            expiresAtMs: snapshot.updatedAtMs + this.ttlMs
-        }, this.maxUsers);
-    }
     async upsertUserDevicesBatch(snapshots) {
-        for (const snapshot of snapshots) {
+        for (let index = 0; index < snapshots.length; index += 1) {
+            const snapshot = snapshots[index];
             (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
                 ...snapshot,
                 expiresAtMs: snapshot.updatedAtMs + this.ttlMs
             }, this.maxUsers);
         }
     }
-    async getUserDevices(userJid, nowMs = Date.now()) {
-        const record = this.records.get(userJid);
-        if (!record) {
-            return null;
-        }
-        if (record.expiresAtMs <= nowMs) {
-            this.records.delete(userJid);
-            return null;
-        }
-        return {
-            userJid: record.userJid,
-            deviceJids: record.deviceJids,
-            updatedAtMs: record.updatedAtMs
-        };
-    }
     async getUserDevicesBatch(userJids, nowMs = Date.now()) {
         return userJids.map((userJid) => {
             const record = this.records.get(userJid);
@@ -59,11 +36,7 @@ class WaDeviceListMemoryStore {
                 this.records.delete(userJid);
                 return null;
             }
-            return {
-                userJid: record.userJid,
-                deviceJids: record.deviceJids,
-                updatedAtMs: record.updatedAtMs
-            };
+            return record;
         });
     }
     async deleteUserDevices(userJid) {

package/dist/store/providers/memory/message.store.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageMemoryStore = void 0;
 const coercion_1 = require("../../../util/coercion");
 const collections_1 = require("../../../util/collections");
-const collections_2 = require("../../../util/collections");
 const DEFAULT_MESSAGE_MEMORY_STORE_LIMITS = Object.freeze({
     messages: 50000
 });
@@ -13,7 +12,12 @@ class WaMessageMemoryStore {
         this.maxMessages = (0, coercion_1.resolvePositive)(options.maxMessages, DEFAULT_MESSAGE_MEMORY_STORE_LIMITS.messages, 'WaMessageMemoryStoreOptions.maxMessages');
     }
     async upsert(record) {
-        (0, collections_2.setBoundedMapEntry)(this.messages, record.id, record, this.maxMessages);
+        (0, collections_1.setBoundedMapEntry)(this.messages, record.id, record, this.maxMessages);
+    }
+    async upsertBatch(records) {
+        for (const record of records) {
+            (0, collections_1.setBoundedMapEntry)(this.messages, record.id, record, this.maxMessages);
+        }
     }
     async getById(id) {
         return this.messages.get(id) ?? null;
@@ -22,9 +26,8 @@ class WaMessageMemoryStore {
         const normalizedLimit = (0, collections_1.normalizeQueryLimit)(limit, 50);
         const records = [];
         for (const record of this.messages.values()) {
-            if (record.threadJid !== threadJid) {
+            if (record.threadJid !== threadJid)
                 continue;
-            }
             if (beforeTimestampMs !== undefined &&
                 (record.timestampMs === undefined || record.timestampMs >= beforeTimestampMs)) {
                 continue;
@@ -32,7 +35,10 @@ class WaMessageMemoryStore {
             records.push(record);
         }
         records.sort((left, right) => (right.timestampMs ?? 0) - (left.timestampMs ?? 0));
-        return records.length <= normalizedLimit ? records : records.slice(0, normalizedLimit);
+        if (records.length > normalizedLimit) {
+            records.length = normalizedLimit;
+        }
+        return records;
     }
     async deleteById(id) {
         return this.messages.delete(id) ? 1 : 0;

package/dist/store/providers/memory/participants.store.js

@@ -17,9 +17,6 @@ class WaParticipantsMemoryStore {
         }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
         this.cleanupTimer.unref();
     }
-    getTtlMs() {
-        return this.ttlMs;
-    }
     async upsertGroupParticipants(snapshot) {
         (0, collections_1.setBoundedMapEntry)(this.records, snapshot.groupJid, {
             ...snapshot,
@@ -35,11 +32,7 @@ class WaParticipantsMemoryStore {
             this.records.delete(groupJid);
             return null;
         }
-        return {
-            groupJid: record.groupJid,
-            participants: record.participants,
-            updatedAtMs: record.updatedAtMs
-        };
+        return record;
     }
     async deleteGroupParticipants(groupJid) {
         return this.records.delete(groupJid) ? 1 : 0;