zapo-js 0.1.1 → 0.2.0

package/dist/esm/store/locks/appstate.lock.js

@@ -0,0 +1,26 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+import { bytesToHex } from '../../util/bytes.js';
+const WA_APPSTATE_CLEAR_KEY = 'appstate:clear';
+export function withAppStateLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        exportData: () => gate.runShared(() => store.exportData()),
+        upsertSyncKeys: (keys) => gate.runShared(() => lock.runMany(keys.map((key) => `appstate:syncKey:${bytesToHex(key.keyId)}`), () => store.upsertSyncKeys(keys))),
+        getSyncKeysBatch: (keyIds) => gate.runShared(() => store.getSyncKeysBatch(keyIds)),
+        getSyncKeyData: (keyId) => gate.runShared(() => store.getSyncKeyData(keyId)),
+        getSyncKeyDataBatch: (keyIds) => gate.runShared(() => store.getSyncKeyDataBatch(keyIds)),
+        getActiveSyncKey: () => gate.runShared(() => store.getActiveSyncKey()),
+        getCollectionState: (collection) => gate.runShared(() => store.getCollectionState(collection)),
+        getCollectionStates: (collections) => gate.runShared(() => store.getCollectionStates(collections)),
+        setCollectionStates: (updates) => gate.runShared(() => lock.runMany(updates.map((update) => `appstate:collection:${update.collection}`), () => store.setCollectionStates(updates))),
+        clear: () => gate.runExclusive(() => lock.run(WA_APPSTATE_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/auth.lock.js

@@ -0,0 +1,15 @@
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_AUTH_KEY = 'credentials';
+export function withAuthLock(store) {
+    const lock = new StoreLock();
+    const destroyStore = store;
+    return {
+        load: () => lock.run(WA_AUTH_KEY, () => store.load()),
+        save: (credentials) => lock.run(WA_AUTH_KEY, () => store.save(credentials)),
+        clear: () => lock.run(WA_AUTH_KEY, () => store.clear()),
+        destroy: async () => {
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/contact.lock.js

@@ -0,0 +1,20 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_CONTACT_CLEAR_KEY = 'contact:clear';
+export function withContactLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsert: (record) => gate.runShared(() => lock.run(`contact:${record.jid}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runShared(() => lock.runMany(records.map((record) => `contact:${record.jid}`), () => store.upsertBatch(records))),
+        getByJid: (jid) => gate.runShared(() => store.getByJid(jid)),
+        deleteByJid: (jid) => gate.runShared(() => lock.run(`contact:${jid}`, () => store.deleteByJid(jid))),
+        clear: () => gate.runExclusive(() => lock.run(WA_CONTACT_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/device-list.lock.js

@@ -0,0 +1,20 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_DEVICE_LIST_CLEAR_KEY = 'deviceList:clear';
+const WA_DEVICE_LIST_CLEANUP_KEY = 'deviceList:cleanup';
+export function withDeviceListLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        upsertUserDevicesBatch: (snapshots) => gate.runShared(() => lock.runMany(snapshots.map((snapshot) => `deviceList:user:${snapshot.userJid}`), () => store.upsertUserDevicesBatch(snapshots))),
+        getUserDevicesBatch: (userJids, nowMs) => gate.runShared(() => store.getUserDevicesBatch(userJids, nowMs)),
+        deleteUserDevices: (userJid) => gate.runShared(() => lock.run(`deviceList:user:${userJid}`, () => store.deleteUserDevices(userJid))),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_DEVICE_LIST_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
+        clear: () => gate.runExclusive(() => lock.run(WA_DEVICE_LIST_CLEAR_KEY, () => store.clear()))
+    };
+}

package/dist/esm/store/locks/message.lock.js

@@ -0,0 +1,21 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_MESSAGE_CLEAR_KEY = 'message:clear';
+export function withMessageLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsert: (record) => gate.runShared(() => lock.run(`message:${record.id}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runShared(() => lock.runMany(records.map((record) => `message:${record.id}`), () => store.upsertBatch(records))),
+        getById: (id) => gate.runShared(() => store.getById(id)),
+        listByThread: (threadJid, limit, beforeTimestampMs) => gate.runShared(() => store.listByThread(threadJid, limit, beforeTimestampMs)),
+        deleteById: (id) => gate.runShared(() => lock.run(`message:${id}`, () => store.deleteById(id))),
+        clear: () => gate.runExclusive(() => lock.run(WA_MESSAGE_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/participants.lock.js

@@ -0,0 +1,20 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_PARTICIPANTS_CLEAR_KEY = 'participants:clear';
+const WA_PARTICIPANTS_CLEANUP_KEY = 'participants:cleanup';
+export function withParticipantsLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        upsertGroupParticipants: (snapshot) => gate.runShared(() => lock.run(`participants:group:${snapshot.groupJid}`, () => store.upsertGroupParticipants(snapshot))),
+        getGroupParticipants: (groupJid, nowMs) => gate.runShared(() => store.getGroupParticipants(groupJid, nowMs)),
+        deleteGroupParticipants: (groupJid) => gate.runShared(() => lock.run(`participants:group:${groupJid}`, () => store.deleteGroupParticipants(groupJid))),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
+        clear: () => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEAR_KEY, () => store.clear()))
+    };
+}

package/dist/esm/store/locks/privacy-token.lock.js

@@ -0,0 +1,18 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+export function withPrivacyTokenLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        upsert: (record) => gate.runShared(() => lock.run(`pt:${record.jid}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runExclusive(() => store.upsertBatch(records)),
+        getByJid: (jid) => gate.runShared(() => store.getByJid(jid)),
+        deleteByJid: (jid) => gate.runShared(() => lock.run(`pt:${jid}`, () => store.deleteByJid(jid))),
+        clear: () => gate.runExclusive(() => store.clear())
+    };
+}

package/dist/esm/store/locks/retry.lock.js

@@ -0,0 +1,29 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_RETRY_CLEANUP_KEY = 'retry:cleanup';
+const WA_RETRY_CLEAR_KEY = 'retry:clear';
+export function withRetryLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    return {
+        getTtlMs: store.getTtlMs?.bind(store),
+        supportsRawReplayPayload: store.supportsRawReplayPayload?.bind(store),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await store.destroy?.();
+        },
+        getOutboundRequesterStatus: (messageId, requesterDeviceJid) => gate.runShared(() => store.getOutboundRequesterStatus(messageId, requesterDeviceJid)),
+        upsertOutboundMessage: (record) => gate.runShared(() => lock.run(`retry:outbound:${record.messageId}`, () => store.upsertOutboundMessage(record))),
+        deleteOutboundMessage: (messageId) => gate.runShared(() => lock.run(`retry:outbound:${messageId}`, () => store.deleteOutboundMessage(messageId))),
+        getOutboundMessage: (messageId) => gate.runShared(() => store.getOutboundMessage(messageId)),
+        updateOutboundMessageState: (messageId, state, updatedAtMs, expiresAtMs) => gate.runShared(() => lock.run(`retry:outbound:${messageId}`, () => store.updateOutboundMessageState(messageId, state, updatedAtMs, expiresAtMs))),
+        markOutboundRequesterDelivered: (messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) => gate.runShared(() => lock.runMany([
+            `retry:outbound:${messageId}`,
+            `retry:outbound:${messageId}:${requesterDeviceJid}`
+        ], () => store.markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs))),
+        incrementInboundCounter: (messageId, requesterJid, updatedAtMs, expiresAtMs) => gate.runShared(() => lock.run(`retry:inbound:${messageId}:${requesterJid}`, () => store.incrementInboundCounter(messageId, requesterJid, updatedAtMs, expiresAtMs))),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_RETRY_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
+        clear: () => gate.runExclusive(() => lock.run(WA_RETRY_CLEAR_KEY, () => store.clear()))
+    };
+}

package/dist/esm/store/locks/sender-key.lock.js

@@ -0,0 +1,52 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+import { signalAddressKey } from '../../protocol/jid.js';
+const WA_SENDER_KEY_CLEAR_KEY = 'senderKey:clear';
+function senderKeyLockKey(groupId, sender) {
+    return `senderKey:${groupId}:${signalAddressKey(sender)}`;
+}
+function senderDistributionLockKey(groupId, sender) {
+    return `senderKeyDistribution:${groupId}:${signalAddressKey(sender)}`;
+}
+function senderAnyLockKey(sender) {
+    return `senderKey:any:${signalAddressKey(sender)}`;
+}
+export function withSenderKeyLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsertSenderKey: (record) => gate.runShared(() => lock.runMany([
+            senderAnyLockKey(record.sender),
+            senderKeyLockKey(record.groupId, record.sender)
+        ], () => store.upsertSenderKey(record))),
+        upsertSenderKeyDistribution: (record) => gate.runShared(() => lock.runMany([
+            senderAnyLockKey(record.sender),
+            senderDistributionLockKey(record.groupId, record.sender)
+        ], () => store.upsertSenderKeyDistribution(record))),
+        upsertSenderKeyDistributions: (records) => gate.runShared(() => lock.runMany(records.flatMap((record) => [
+            senderAnyLockKey(record.sender),
+            senderDistributionLockKey(record.groupId, record.sender)
+        ]), () => store.upsertSenderKeyDistributions(records))),
+        getGroupSenderKeyList: (groupId) => gate.runShared(() => store.getGroupSenderKeyList(groupId)),
+        getDeviceSenderKey: (groupId, sender) => gate.runShared(() => store.getDeviceSenderKey(groupId, sender)),
+        getDeviceSenderKeyDistributions: (groupId, senders) => gate.runShared(() => store.getDeviceSenderKeyDistributions(groupId, senders)),
+        deleteDeviceSenderKey: (target, groupId) => gate.runShared(() => lock.runMany(groupId
+            ? [
+                senderAnyLockKey(target),
+                senderKeyLockKey(groupId, target),
+                senderDistributionLockKey(groupId, target)
+            ]
+            : [senderAnyLockKey(target)], () => store.deleteDeviceSenderKey(target, groupId))),
+        markForgetSenderKey: (groupId, participants) => gate.runShared(() => lock.runMany(participants.flatMap((participant) => [
+            senderAnyLockKey(participant),
+            senderKeyLockKey(groupId, participant)
+        ]), () => store.markForgetSenderKey(groupId, participants))),
+        clear: () => gate.runExclusive(() => lock.run(WA_SENDER_KEY_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/signal.lock.js

@@ -0,0 +1,63 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_SIGNAL_REGISTRATION_KEY = 'signal:registration';
+const WA_SIGNAL_SIGNED_PREKEY_KEY = 'signal:signedPreKey';
+const WA_SIGNAL_PREKEYS_KEY = 'signal:prekeys';
+const WA_SIGNAL_SERVER_HAS_PREKEYS_KEY = 'signal:serverHasPreKeys';
+const WA_SIGNAL_CLEAR_KEY = 'signal:clear';
+export function withSignalLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    let cachedRegInfo;
+    return {
+        getRegistrationInfo: () => gate.runShared(async () => {
+            if (cachedRegInfo !== undefined) {
+                return cachedRegInfo;
+            }
+            const info = await store.getRegistrationInfo();
+            cachedRegInfo = info;
+            return info;
+        }),
+        setRegistrationInfo: (info) => gate.runShared(() => lock.run(WA_SIGNAL_REGISTRATION_KEY, async () => {
+            await store.setRegistrationInfo(info);
+            cachedRegInfo = info;
+        })),
+        getSignedPreKey: () => gate.runShared(() => store.getSignedPreKey()),
+        setSignedPreKey: (record) => gate.runShared(() => lock.run(WA_SIGNAL_SIGNED_PREKEY_KEY, () => store.setSignedPreKey(record))),
+        getSignedPreKeyById: (keyId) => gate.runShared(() => store.getSignedPreKeyById(keyId)),
+        setSignedPreKeyRotationTs: (value) => gate.runShared(() => lock.run(WA_SIGNAL_SIGNED_PREKEY_KEY, () => store.setSignedPreKeyRotationTs(value))),
+        getSignedPreKeyRotationTs: () => gate.runShared(() => store.getSignedPreKeyRotationTs()),
+        putPreKey: (record) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.putPreKey(record))),
+        getOrGenPreKeys: (count, generator) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.getOrGenPreKeys(count, generator))),
+        getPreKeyById: (keyId) => gate.runShared(() => store.getPreKeyById(keyId)),
+        getPreKeysById: (keyIds) => gate.runShared(() => store.getPreKeysById(keyIds)),
+        consumePreKeyById: (keyId) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.consumePreKeyById(keyId))),
+        getOrGenSinglePreKey: (generator) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.getOrGenSinglePreKey(generator))),
+        markKeyAsUploaded: (keyId) => gate.runShared(() => lock.run(WA_SIGNAL_PREKEYS_KEY, () => store.markKeyAsUploaded(keyId))),
+        setServerHasPreKeys: (value) => gate.runShared(() => lock.run(WA_SIGNAL_SERVER_HAS_PREKEYS_KEY, () => store.setServerHasPreKeys(value))),
+        getServerHasPreKeys: () => gate.runShared(() => store.getServerHasPreKeys()),
+        getSignalMeta: () => gate.runShared(() => store.getSignalMeta()),
+        hasSession: (address) => gate.runShared(() => store.hasSession(address)),
+        hasSessions: (addresses) => gate.runShared(() => store.hasSessions(addresses)),
+        getSession: (address) => gate.runShared(() => store.getSession(address)),
+        getSessionsBatch: (addresses) => gate.runShared(() => store.getSessionsBatch(addresses)),
+        // Session and identity read-modify-write semantics are serialized in SignalProtocol per address.
+        setSession: (address, session) => gate.runShared(() => store.setSession(address, session)),
+        setSessionsBatch: (entries) => gate.runShared(() => store.setSessionsBatch(entries)),
+        deleteSession: (address) => gate.runShared(() => store.deleteSession(address)),
+        getRemoteIdentity: (address) => gate.runShared(() => store.getRemoteIdentity(address)),
+        getRemoteIdentities: (addresses) => gate.runShared(() => store.getRemoteIdentities(addresses)),
+        setRemoteIdentity: (address, identityKey) => gate.runShared(() => store.setRemoteIdentity(address, identityKey)),
+        setRemoteIdentities: (entries) => gate.runShared(() => store.setRemoteIdentities(entries)),
+        clear: () => gate.runExclusive(() => lock.run(WA_SIGNAL_CLEAR_KEY, async () => {
+            await store.clear();
+            cachedRegInfo = undefined;
+        })),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

package/dist/esm/store/locks/thread.lock.js

@@ -0,0 +1,21 @@
+import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
+import { StoreLock } from '../../infra/perf/StoreLock.js';
+const WA_THREAD_CLEAR_KEY = 'thread:clear';
+export function withThreadLock(store) {
+    const lock = new StoreLock();
+    const gate = new SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        upsert: (record) => gate.runShared(() => lock.run(`thread:${record.jid}`, () => store.upsert(record))),
+        upsertBatch: (records) => gate.runShared(() => lock.runMany(records.map((record) => `thread:${record.jid}`), () => store.upsertBatch(records))),
+        getByJid: (jid) => gate.runShared(() => store.getByJid(jid)),
+        list: (limit) => gate.runShared(() => store.list(limit)),
+        deleteByJid: (jid) => gate.runShared(() => lock.run(`thread:${jid}`, () => store.deleteByJid(jid))),
+        clear: () => gate.runExclusive(() => lock.run(WA_THREAD_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.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,11 +31,8 @@ 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),
+    getUserDevicesBatch: async (userJids, _nowMs) => new Array(userJids.length).fill(null),
     deleteUserDevices: async (_userJid) => 0,
     cleanupExpired: async (_nowMs) => 0,
     clear: async () => { },

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

@@ -1,19 +1,12 @@
 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({
     syncKeys: 4096,
     collectionEntries: 50000
 });
-function toBoundedMap(entries, maxEntries) {
-    const map = new Map();
-    for (const [key, value] of entries) {
-        setBoundedMapEntry(map, key, value, maxEntries);
-    }
-    return map;
-}
 export class WaAppStateMemoryStore {
     constructor(initial, options = {}) {
         this.keys = new Map();
@@ -22,16 +15,21 @@ 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;
                 }
+                const indexValueMap = new Map();
+                for (const [key, value] of Object.entries(collection.indexValueMap)) {
+                    setBoundedMapEntry(indexValueMap, key, value, this.maxCollectionEntries);
+                }
                 this.collections.set(collectionName, {
+                    initialized: true,
                     version: collection.version,
                     hash: collection.hash,
-                    indexValueMap: toBoundedMap(Object.entries(collection.indexValueMap), this.maxCollectionEntries)
+                    indexValueMap
                 });
             }
         }
@@ -54,7 +52,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;
@@ -64,11 +62,22 @@ export class WaAppStateMemoryStore {
         }
         return inserted;
     }
-    async getSyncKey(keyId) {
-        return this.keys.get(keyIdToHex(keyId)) ?? null;
+    async getSyncKeysBatch(keyIds) {
+        const keys = new Array(keyIds.length);
+        for (let index = 0; index < keyIds.length; index += 1) {
+            keys[index] = this.keys.get(bytesToHex(keyIds[index])) ?? null;
+        }
+        return keys;
     }
     async getSyncKeyData(keyId) {
-        return this.keys.get(keyIdToHex(keyId))?.keyData ?? null;
+        return this.keys.get(bytesToHex(keyId))?.keyData ?? null;
+    }
+    async getSyncKeyDataBatch(keyIds) {
+        const keys = new Array(keyIds.length);
+        for (let index = 0; index < keyIds.length; index += 1) {
+            keys[index] = this.keys.get(bytesToHex(keyIds[index]))?.keyData ?? null;
+        }
+        return keys;
     }
     async getActiveSyncKey() {
         return pickActiveSyncKey(this.keys.values());
@@ -77,6 +86,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,12 +95,24 @@ export class WaAppStateMemoryStore {
         }
         return state;
     }
+    async getCollectionStates(collections) {
+        const result = new Array(collections.length);
+        for (let index = 0; index < collections.length; index += 1) {
+            result[index] = await this.getCollectionState(collections[index]);
+        }
+        return result;
+    }
     async setCollectionStates(updates) {
         for (const update of updates) {
+            const indexValueMap = new Map();
+            for (const [key, value] of update.indexValueMap.entries()) {
+                setBoundedMapEntry(indexValueMap, key, value, this.maxCollectionEntries);
+            }
             this.collections.set(update.collection, {
+                initialized: true,
                 version: update.version,
                 hash: update.hash,
-                indexValueMap: toBoundedMap(update.indexValueMap.entries(), this.maxCollectionEntries)
+                indexValueMap
             });
         }
     }

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,54 +14,32 @@ 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 snapshots = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            const userJid = userJids[index];
             const record = this.records.get(userJid);
             if (!record) {
-                return null;
+                snapshots[index] = null;
+                continue;
             }
             if (record.expiresAtMs <= nowMs) {
                 this.records.delete(userJid);
-                return null;
+                snapshots[index] = null;
+                continue;
             }
-            return {
-                userJid: record.userJid,
-                deviceJids: record.deviceJids,
-                updatedAtMs: record.updatedAtMs
-            };
-        });
+            snapshots[index] = record;
+        }
+        return snapshots;
     }
     async deleteUserDevices(userJid) {
         return this.records.delete(userJid) ? 1 : 0;

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;