zapo-js 0.1.2 → 0.3.0

package/dist/store/locks/message-secret.lock.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMessageSecretLock = withMessageSecretLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+function withMessageSecretLock(store) {
+    const gate = new SharedExclusiveGate_1.SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        get: (messageId, nowMs) => gate.runShared(() => store.get(messageId, nowMs)),
+        getBatch: (messageIds, nowMs) => gate.runShared(() => store.getBatch(messageIds, nowMs)),
+        set: (messageId, entry) => gate.runShared(() => store.set(messageId, entry)),
+        setBatch: (entries) => gate.runShared(() => store.setBatch(entries)),
+        cleanupExpired: (nowMs) => gate.runExclusive(() => store.cleanupExpired(nowMs)),
+        clear: () => gate.runExclusive(() => store.clear()),
+        destroy: async () => {
+            await gate.close();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMessageLock = withMessageLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const WA_MESSAGE_CLEAR_KEY = 'message:clear';
+function withMessageLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.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/store/locks/participants.lock.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withParticipantsLock = withParticipantsLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const WA_PARTICIPANTS_CLEAR_KEY = 'participants:clear';
+const WA_PARTICIPANTS_CLEANUP_KEY = 'participants:cleanup';
+function withParticipantsLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.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/store/locks/pre-key.lock.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPreKeyLock = withPreKeyLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const WA_PREKEY_KEY = 'prekey:prekeys';
+const WA_PREKEY_SERVER_KEY = 'prekey:serverHasPreKeys';
+const WA_PREKEY_CLEAR_KEY = 'prekey:clear';
+function withPreKeyLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        putPreKey: (record) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.putPreKey(record))),
+        getOrGenPreKeys: (count, generator) => gate.runShared(() => lock.run(WA_PREKEY_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_PREKEY_KEY, () => store.consumePreKeyById(keyId))),
+        getOrGenSinglePreKey: (generator) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.getOrGenSinglePreKey(generator))),
+        markKeyAsUploaded: (keyId) => gate.runShared(() => lock.run(WA_PREKEY_KEY, () => store.markKeyAsUploaded(keyId))),
+        setServerHasPreKeys: (value) => gate.runShared(() => lock.run(WA_PREKEY_SERVER_KEY, () => store.setServerHasPreKeys(value))),
+        getServerHasPreKeys: () => gate.runShared(() => store.getServerHasPreKeys()),
+        clear: () => gate.runExclusive(() => lock.run(WA_PREKEY_CLEAR_KEY, () => store.clear())),
+        destroy: async () => {
+            await gate.close();
+            await lock.shutdown();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPrivacyTokenLock = withPrivacyTokenLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+function withPrivacyTokenLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.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/store/locks/retry.lock.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetryLock = withRetryLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const WA_RETRY_CLEANUP_KEY = 'retry:cleanup';
+const WA_RETRY_CLEAR_KEY = 'retry:clear';
+function withRetryLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.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/store/locks/sender-key.lock.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSenderKeyLock = withSenderKeyLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const jid_1 = require("../../protocol/jid");
+const WA_SENDER_KEY_CLEAR_KEY = 'senderKey:clear';
+function senderKeyLockKey(groupId, sender) {
+    return `senderKey:${groupId}:${(0, jid_1.signalAddressKey)(sender)}`;
+}
+function senderDistributionLockKey(groupId, sender) {
+    return `senderKeyDistribution:${groupId}:${(0, jid_1.signalAddressKey)(sender)}`;
+}
+function senderAnyLockKey(sender) {
+    return `senderKey:any:${(0, jid_1.signalAddressKey)(sender)}`;
+}
+function withSenderKeyLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.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/store/locks/session.lock.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSessionLock = withSessionLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+function withSessionLock(store) {
+    const gate = new SharedExclusiveGate_1.SharedExclusiveGate();
+    const destroyStore = store;
+    return {
+        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)),
+        setSession: (address, session) => gate.runShared(() => store.setSession(address, session)),
+        setSessionsBatch: (entries) => gate.runShared(() => store.setSessionsBatch(entries)),
+        deleteSession: (address) => gate.runShared(() => store.deleteSession(address)),
+        clear: () => gate.runExclusive(() => store.clear()),
+        destroy: async () => {
+            await gate.close();
+            await destroyStore.destroy?.();
+        }
+    };
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSignalLock = withSignalLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const WA_SIGNAL_REGISTRATION_KEY = 'signal:registration';
+const WA_SIGNAL_SIGNED_PREKEY_KEY = 'signal:signedPreKey';
+const WA_SIGNAL_CLEAR_KEY = 'signal:clear';
+function withSignalLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.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()),
+        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/store/locks/thread.lock.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withThreadLock = withThreadLock;
+const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
+const WA_THREAD_CLEAR_KEY = 'thread:clear';
+function withThreadLock(store) {
+    const lock = new StoreLock_1.StoreLock();
+    const gate = new SharedExclusiveGate_1.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/store/noop.store.js

@@ -1,7 +1,15 @@
 "use strict";
 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;
+exports.NOOP_DEVICE_LIST_STORE = exports.NOOP_PARTICIPANTS_STORE = exports.NOOP_RETRY_STORE = exports.NOOP_CONTACT_STORE = exports.NOOP_THREAD_STORE = exports.NOOP_MESSAGE_STORE = exports.NOOP_MESSAGE_SECRET_STORE = void 0;
 const EMPTY_STORE_LIST = Object.freeze([]);
+exports.NOOP_MESSAGE_SECRET_STORE = Object.freeze({
+    get: async (_messageId) => null,
+    getBatch: async (messageIds) => new Array(messageIds.length).fill(null),
+    set: async (_messageId, _entry) => { },
+    setBatch: async (_entries) => { },
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { }
+});
 exports.NOOP_MESSAGE_STORE = Object.freeze({
     upsert: async (_record) => { },
     upsertBatch: async (_records) => { },
@@ -25,6 +33,18 @@ exports.NOOP_CONTACT_STORE = Object.freeze({
     deleteByJid: async (_jid) => 0,
     clear: async () => { }
 });
+exports.NOOP_RETRY_STORE = Object.freeze({
+    getOutboundRequesterStatus: async () => null,
+    upsertOutboundMessage: async (_record) => { },
+    deleteOutboundMessage: async (_messageId) => 0,
+    getOutboundMessage: async (_messageId) => null,
+    updateOutboundMessageState: async () => { },
+    markOutboundRequesterDelivered: async () => { },
+    incrementInboundCounter: async () => 0,
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { },
+    destroy: async () => { }
+});
 exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
     upsertGroupParticipants: async (_snapshot) => { },
     getGroupParticipants: async (_groupJid, _nowMs) => null,
@@ -35,7 +55,7 @@ exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
 });
 exports.NOOP_DEVICE_LIST_STORE = Object.freeze({
     upsertUserDevicesBatch: async (_snapshots) => { },
-    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/store/providers/memory/appstate.store.js

@@ -10,13 +10,6 @@ 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) {
-        (0, collections_1.setBoundedMapEntry)(map, key, value, maxEntries);
-    }
-    return map;
-}
 class WaAppStateMemoryStore {
     constructor(initial, options = {}) {
         this.keys = new Map();
@@ -31,11 +24,15 @@ class WaAppStateMemoryStore {
                 if (!collection) {
                     continue;
                 }
+                const indexValueMap = new Map();
+                for (const [key, value] of Object.entries(collection.indexValueMap)) {
+                    (0, collections_1.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
                 });
             }
         }
@@ -68,14 +65,22 @@ class WaAppStateMemoryStore {
         }
         return inserted;
     }
-    async getSyncKey(keyId) {
-        return this.keys.get((0, bytes_1.bytesToHex)(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((0, bytes_1.bytesToHex)(keyIds[index])) ?? null;
+        }
+        return keys;
     }
     async getSyncKeyData(keyId) {
         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);
+        const keys = new Array(keyIds.length);
+        for (let index = 0; index < keyIds.length; index += 1) {
+            keys[index] = this.keys.get((0, bytes_1.bytesToHex)(keyIds[index]))?.keyData ?? null;
+        }
+        return keys;
     }
     async getActiveSyncKey() {
         return (0, utils_1.pickActiveSyncKey)(this.keys.values());
@@ -96,28 +101,21 @@ class WaAppStateMemoryStore {
     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;
+            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()) {
+                (0, collections_1.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/store/providers/memory/device-list.store.js

@@ -9,6 +9,9 @@ const DEFAULTS = Object.freeze({
 });
 class WaDeviceListMemoryStore {
     constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('device-list ttlMs must be a positive finite number');
+        }
         this.records = new Map();
         this.ttlMs = ttlMs;
         this.maxUsers = (0, coercion_1.resolvePositive)(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
@@ -27,17 +30,22 @@ class WaDeviceListMemoryStore {
         }
     }
     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 record;
-        });
+            snapshots[index] = record;
+        }
+        return snapshots;
     }
     async deleteUserDevices(userJid) {
         return this.records.delete(userJid) ? 1 : 0;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaIdentityMemoryStore = void 0;
+const jid_1 = require("../../../protocol/jid");
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_MAX_REMOTE_IDENTITIES = 8192;
+class WaIdentityMemoryStore {
+    constructor(options = {}) {
+        this.remoteIdentities = new Map();
+        this.maxRemoteIdentities = (0, coercion_1.resolvePositive)(options.maxRemoteIdentities, DEFAULT_MAX_REMOTE_IDENTITIES, 'WaIdentityMemoryStoreOptions.maxRemoteIdentities');
+    }
+    async getRemoteIdentity(address) {
+        return this.remoteIdentities.get((0, jid_1.signalAddressKey)(address)) ?? null;
+    }
+    async getRemoteIdentities(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.remoteIdentities.get((0, jid_1.signalAddressKey)(addresses[i])) ?? null;
+        }
+        return result;
+    }
+    async setRemoteIdentity(address, identityKey) {
+        (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(address), identityKey, this.maxRemoteIdentities);
+    }
+    async setRemoteIdentities(entries) {
+        for (const entry of entries) {
+            (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(entry.address), entry.identityKey, this.maxRemoteIdentities);
+        }
+    }
+    async clear() {
+        this.remoteIdentities.clear();
+    }
+}
+exports.WaIdentityMemoryStore = WaIdentityMemoryStore;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaMessageSecretMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULTS = Object.freeze({
+    ttlMs: 30 * 60 * 1000,
+    maxSecrets: 10000
+});
+class WaMessageSecretMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('message-secret ttlMs must be a positive finite number');
+        }
+        this.secrets = new Map();
+        this.ttlMs = ttlMs;
+        this.maxSecrets = (0, coercion_1.resolvePositive)(options.maxSecrets, DEFAULTS.maxSecrets, 'WaMessageSecretMemoryStoreOptions.maxSecrets');
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    async get(messageId, nowMs = Date.now()) {
+        const cached = this.secrets.get(messageId);
+        if (!cached)
+            return null;
+        if (cached.expiresAtMs <= nowMs) {
+            this.secrets.delete(messageId);
+            return null;
+        }
+        return { secret: cached.secret, senderJid: cached.senderJid };
+    }
+    async getBatch(messageIds, nowMs = Date.now()) {
+        const result = new Array(messageIds.length);
+        for (let i = 0; i < messageIds.length; i += 1) {
+            const cached = this.secrets.get(messageIds[i]);
+            if (!cached) {
+                result[i] = null;
+                continue;
+            }
+            if (cached.expiresAtMs <= nowMs) {
+                this.secrets.delete(messageIds[i]);
+                result[i] = null;
+                continue;
+            }
+            result[i] = { secret: cached.secret, senderJid: cached.senderJid };
+        }
+        return result;
+    }
+    async set(messageId, entry) {
+        (0, collections_1.setBoundedMapEntry)(this.secrets, messageId, {
+            secret: entry.secret,
+            senderJid: entry.senderJid,
+            expiresAtMs: Date.now() + this.ttlMs
+        }, this.maxSecrets);
+    }
+    async setBatch(entries) {
+        const nowMs = Date.now();
+        for (let i = 0; i < entries.length; i += 1) {
+            (0, collections_1.setBoundedMapEntry)(this.secrets, entries[i].messageId, {
+                secret: entries[i].entry.secret,
+                senderJid: entries[i].entry.senderJid,
+                expiresAtMs: nowMs + this.ttlMs
+            }, this.maxSecrets);
+        }
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [messageId, entry] of this.secrets) {
+            if (entry.expiresAtMs > nowMs)
+                continue;
+            this.secrets.delete(messageId);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.secrets.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        this.secrets.clear();
+    }
+}
+exports.WaMessageSecretMemoryStore = WaMessageSecretMemoryStore;

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

@@ -9,6 +9,9 @@ const DEFAULTS = Object.freeze({
 });
 class WaParticipantsMemoryStore {
     constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('participants ttlMs must be a positive finite number');
+        }
         this.records = new Map();
         this.ttlMs = ttlMs;
         this.maxGroups = (0, coercion_1.resolvePositive)(options.maxGroups, DEFAULTS.maxGroups, 'WaParticipantsMemoryStoreOptions.maxGroups');