zapo-js 0.1.0 → 0.1.2

package/dist/esm/signal/session/resolver.js

@@ -0,0 +1,186 @@
+import { toSerializedPubKey } from '../../crypto/core/keys.js';
+import { normalizeDeviceJid, parseSignalAddressFromJid } from '../../protocol/jid.js';
+import { uint8Equal } from '../../util/bytes.js';
+import { toError } from '../../util/primitives.js';
+export function createSignalSessionResolver(options) {
+    const { signalProtocol, signalStore, signalIdentitySync, signalSessionSync, logger } = options;
+    const ensureSession = async (address, jid, expectedIdentity, reasonIdentity = false) => {
+        const expectedSerializedIdentity = expectedIdentity
+            ? toSerializedPubKey(expectedIdentity)
+            : null;
+        if (reasonIdentity) {
+            await signalIdentitySync.syncIdentityKeys([jid]);
+        }
+        if (await signalProtocol.hasSession(address)) {
+            if (expectedSerializedIdentity) {
+                const storedIdentity = await signalStore.getRemoteIdentity(address);
+                if (!storedIdentity || !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 = toSerializedPubKey(fetched.bundle.identity);
+        if (reasonIdentity) {
+            const storedIdentity = await signalStore.getRemoteIdentity(address);
+            if (storedIdentity && !uint8Equal(remoteIdentity, storedIdentity)) {
+                throw new Error('identity mismatch');
+            }
+        }
+        if (expectedSerializedIdentity && !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 = normalizeDeviceJid(targetJids[index]);
+            if (seenTargetJids.has(jid)) {
+                continue;
+            }
+            seenTargetJids.add(jid);
+            normalizedTargetJids.push(jid);
+            normalizedTargetAddresses.push(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(normalizeDeviceJid(jid), identity);
+                }
+                catch (error) {
+                    logger.trace('ignoring malformed expected identity jid during batch normalization', { jid, message: 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(toSerializedPubKey(expectedIdentity));
+            }
+            const storedIdentities = await signalStore.getRemoteIdentities(identityAddresses);
+            for (let index = 0; index < storedIdentities.length; index += 1) {
+                const storedIdentity = storedIdentities[index];
+                if (!storedIdentity ||
+                    !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 = toSerializedPubKey(result.bundle.identity);
+                if (expectedIdentity &&
+                    !uint8Equal(remoteIdentity, 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 = 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 = 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/esm/signal/store/sqlite.js

@@ -1,5 +1,6 @@
 import { proto } from '../../proto.js';
 import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { assertByteLength } from '../../util/bytes.js';
 import { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asString, toBoolOrUndef } from '../../util/coercion.js';
 export function toSignalAddressParts(address) {
     return {
@@ -94,17 +95,11 @@ function encodeSignalRecvChain(chain) {
 }
 function decodeSignalMessageKey(messageKey, field) {
     const cipherKey = asBytes(messageKey.cipherKey, `${field}.cipherKey`);
-    if (cipherKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
-    }
+    assertByteLength(cipherKey, 32, `invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
     const macKey = asBytes(messageKey.macKey, `${field}.macKey`);
-    if (macKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.macKey length ${macKey.byteLength}`);
-    }
+    assertByteLength(macKey, 32, `invalid ${field}.macKey length ${macKey.byteLength}`);
     const iv = asBytes(messageKey.iv, `${field}.iv`);
-    if (iv.byteLength !== 16) {
-        throw new Error(`invalid ${field}.iv length ${iv.byteLength}`);
-    }
+    assertByteLength(iv, 16, `invalid ${field}.iv length ${iv.byteLength}`);
     return {
         index: asNumber(messageKey.index, `${field}.index`),
         cipherKey,
@@ -118,13 +113,9 @@ function decodeSignalRecvChain(chain, field) {
         throw new Error(`missing ${field}.chainKey`);
     }
     const ratchetPubKey = asBytes(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    if (ratchetPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    }
+    assertByteLength(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
     const chainKeyBytes = asBytes(chainKey.key, `${field}.chainKey.key`);
-    if (chainKeyBytes.byteLength !== 32) {
-        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    }
+    assertByteLength(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
     return {
         ratchetPubKey,
         nextMsgIndex: asNumber(chainKey.index, `${field}.chainKey.index`),
@@ -141,17 +132,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}`);
-    }
+    assertByteLength(privateKey, 32, `invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
     const ratchetPubKey = asBytes(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    if (ratchetPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    }
+    assertByteLength(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
     const chainKeyBytes = asBytes(chainKey.key, `${field}.chainKey.key`);
-    if (chainKeyBytes.byteLength !== 32) {
-        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    }
+    assertByteLength(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
     return {
         ratchetKey: {
             pubKey: ratchetPubKey,
@@ -168,26 +153,20 @@ function decodeSignalSessionSnapshot(session, field) {
     }
     const pendingPreKey = session.pendingPreKey;
     const localPubKey = asBytes(session.localIdentityPublic, `${field}.localIdentityPublic`);
-    if (localPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
-    }
+    assertByteLength(localPubKey, 33, `invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
     const remotePubKey = asBytes(session.remoteIdentityPublic, `${field}.remoteIdentityPublic`);
-    if (remotePubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
-    }
+    assertByteLength(remotePubKey, 33, `invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
     const rootKey = asBytes(session.rootKey, `${field}.rootKey`);
-    if (rootKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.rootKey length ${rootKey.byteLength}`);
-    }
+    assertByteLength(rootKey, 32, `invalid ${field}.rootKey length ${rootKey.byteLength}`);
     const localOneTimePubKey = pendingPreKey
         ? asBytes(pendingPreKey.baseKey, `${field}.pendingPreKey.baseKey`)
         : null;
-    if (localOneTimePubKey && localOneTimePubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
+    if (localOneTimePubKey) {
+        assertByteLength(localOneTimePubKey, 33, `invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
     }
     const aliceBaseKey = asOptionalBytes(session.aliceBaseKey, `${field}.aliceBaseKey`) ?? null;
-    if (aliceBaseKey && aliceBaseKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
+    if (aliceBaseKey) {
+        assertByteLength(aliceBaseKey, 33, `invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
     }
     return {
         local: {

package/dist/esm/store/createStore.js

@@ -101,18 +101,17 @@ export 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') ||
@@ -133,7 +132,8 @@ export 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 WaAuthSqliteStore(sqliteOptions);
@@ -258,8 +258,7 @@ export 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();
             }
         },
@@ -268,9 +267,8 @@ export 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/esm/store/noop.store.js

@@ -1,8 +1,7 @@
 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;
 export const 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,
@@ -10,6 +9,7 @@ export const NOOP_MESSAGE_STORE = Object.freeze({
 });
 export const 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,
@@ -17,12 +17,12 @@ export const NOOP_THREAD_STORE = Object.freeze({
 });
 export const NOOP_CONTACT_STORE = Object.freeze({
     upsert: async (_record) => { },
+    upsertBatch: async (_records) => { },
     getByJid: async (_jid) => null,
     deleteByJid: async (_jid) => 0,
     clear: async () => { }
 });
 export const NOOP_PARTICIPANTS_STORE = Object.freeze({
-    getTtlMs: () => DEFAULT_PARTICIPANTS_CACHE_TTL_MS,
     upsertGroupParticipants: async (_snapshot) => { },
     getGroupParticipants: async (_groupJid, _nowMs) => null,
     deleteGroupParticipants: async (_groupJid) => 0,
@@ -31,10 +31,7 @@ export const NOOP_PARTICIPANTS_STORE = Object.freeze({
     destroy: async () => { }
 });
 export const 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/esm/store/providers/memory/appstate.store.js

@@ -1,6 +1,6 @@
 import { APP_STATE_EMPTY_LT_HASH } from '../../../appstate/constants.js';
-import { keyIdToHex, pickActiveSyncKey } from '../../../appstate/utils.js';
-import { uint8Equal } from '../../../util/bytes.js';
+import { pickActiveSyncKey } from '../../../appstate/utils.js';
+import { bytesToHex, uint8Equal } from '../../../util/bytes.js';
 import { resolvePositive } from '../../../util/coercion.js';
 import { setBoundedMapEntry } from '../../../util/collections.js';
 const DEFAULT_APPSTATE_MEMORY_STORE_LIMITS = Object.freeze({
@@ -22,13 +22,14 @@ export class WaAppStateMemoryStore {
         this.maxCollectionEntries = resolvePositive(options.maxCollectionEntries, DEFAULT_APPSTATE_MEMORY_STORE_LIMITS.collectionEntries, 'WaAppStateMemoryStoreOptions.maxCollectionEntries');
         if (initial) {
             for (const key of initial.keys) {
-                setBoundedMapEntry(this.keys, keyIdToHex(key.keyId), key, this.maxSyncKeys);
+                setBoundedMapEntry(this.keys, 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)
@@ -54,7 +55,7 @@ export class WaAppStateMemoryStore {
     async upsertSyncKeys(keys) {
         let inserted = 0;
         for (const key of keys) {
-            const keyHex = keyIdToHex(key.keyId);
+            const keyHex = bytesToHex(key.keyId);
             const existing = this.keys.get(keyHex);
             if (existing && uint8Equal(existing.keyData, key.keyData)) {
                 continue;
@@ -65,10 +66,13 @@ export class WaAppStateMemoryStore {
         return inserted;
     }
     async getSyncKey(keyId) {
-        return this.keys.get(keyIdToHex(keyId)) ?? null;
+        return this.keys.get(bytesToHex(keyId)) ?? null;
     }
     async getSyncKeyData(keyId) {
-        return this.keys.get(keyIdToHex(keyId))?.keyData ?? null;
+        return this.keys.get(bytesToHex(keyId))?.keyData ?? null;
+    }
+    async getSyncKeyDataBatch(keyIds) {
+        return keyIds.map((keyId) => this.keys.get(bytesToHex(keyId))?.keyData ?? null);
     }
     async getActiveSyncKey() {
         return pickActiveSyncKey(this.keys.values());
@@ -77,6 +81,7 @@ export class WaAppStateMemoryStore {
         let state = this.collections.get(collection);
         if (!state) {
             state = {
+                initialized: false,
                 version: 0,
                 hash: APP_STATE_EMPTY_LT_HASH,
                 indexValueMap: new Map()
@@ -85,9 +90,28 @@ export 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: 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/esm/store/providers/memory/contact.store.js

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

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

@@ -14,38 +14,15 @@ export class WaDeviceListMemoryStore {
         }, resolveCleanupIntervalMs(ttlMs));
         this.cleanupTimer.unref();
     }
-    getTtlMs() {
-        return this.ttlMs;
-    }
-    async upsertUserDevices(snapshot) {
-        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];
             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);
@@ -56,11 +33,7 @@ export 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/esm/store/providers/memory/message.store.js

@@ -1,6 +1,5 @@
 import { resolvePositive } from '../../../util/coercion.js';
-import { normalizeQueryLimit } from '../../../util/collections.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
+import { normalizeQueryLimit, setBoundedMapEntry } from '../../../util/collections.js';
 const DEFAULT_MESSAGE_MEMORY_STORE_LIMITS = Object.freeze({
     messages: 50000
 });
@@ -12,6 +11,11 @@ export class WaMessageMemoryStore {
     async upsert(record) {
         setBoundedMapEntry(this.messages, record.id, record, this.maxMessages);
     }
+    async upsertBatch(records) {
+        for (const record of records) {
+            setBoundedMapEntry(this.messages, record.id, record, this.maxMessages);
+        }
+    }
     async getById(id) {
         return this.messages.get(id) ?? null;
     }
@@ -19,9 +23,8 @@ export class WaMessageMemoryStore {
         const normalizedLimit = 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;
@@ -29,7 +32,10 @@ export 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/esm/store/providers/memory/participants.store.js

@@ -14,9 +14,6 @@ export class WaParticipantsMemoryStore {
         }, resolveCleanupIntervalMs(ttlMs));
         this.cleanupTimer.unref();
     }
-    getTtlMs() {
-        return this.ttlMs;
-    }
     async upsertGroupParticipants(snapshot) {
         setBoundedMapEntry(this.records, snapshot.groupJid, {
             ...snapshot,
@@ -32,11 +29,7 @@ export 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;

package/dist/esm/store/providers/memory/sender-key.store.js

@@ -1,6 +1,6 @@
+import { signalAddressKey } from '../../../protocol/jid.js';
 import { resolvePositive } from '../../../util/coercion.js';
 import { setBoundedMapEntry } from '../../../util/collections.js';
-import { signalAddressKey } from '../../../util/signal-address.js';
 const DEFAULT_SENDER_KEY_STORE_LIMITS = Object.freeze({
     senderKeys: 8192,
     senderDistributions: 8192
@@ -45,10 +45,6 @@ export class SenderKeyMemoryStore {
         const record = this.senderKeys.get(this.makeKey(groupId, sender));
         return record ?? null;
     }
-    async getDeviceSenderKeyDistribution(groupId, sender) {
-        const record = this.senderDistributions.get(this.makeKey(groupId, sender));
-        return record ?? null;
-    }
     async getDeviceSenderKeyDistributions(groupId, senders) {
         return senders.map((sender) => this.senderDistributions.get(this.makeKey(groupId, sender)) ?? null);
     }
@@ -60,8 +56,10 @@ export class SenderKeyMemoryStore {
     }
     async markForgetSenderKey(groupId, participants) {
         let deleted = 0;
-        for (const participant of participants) {
-            deleted += await this.deleteDeviceSenderKey(participant, groupId);
+        for (let index = 0; index < participants.length; index += 1) {
+            const participant = participants[index];
+            deleted += this.deleteMatching(this.senderKeys, participant, groupId);
+            deleted += this.deleteMatching(this.senderDistributions, participant, groupId);
         }
         return deleted;
     }