zapo-js 0.1.1 → 0.2.0

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/signal.lock.js

@@ -0,0 +1,66 @@
+"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_PREKEYS_KEY = 'signal:prekeys';
+const WA_SIGNAL_SERVER_HAS_PREKEYS_KEY = 'signal:serverHasPreKeys';
+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()),
+        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/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

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOOP_DEVICE_LIST_STORE = exports.NOOP_PARTICIPANTS_STORE = exports.NOOP_CONTACT_STORE = exports.NOOP_THREAD_STORE = exports.NOOP_MESSAGE_STORE = void 0;
 const EMPTY_STORE_LIST = Object.freeze([]);
-const DEFAULT_PARTICIPANTS_CACHE_TTL_MS = 5 * 60 * 1000;
-const DEFAULT_DEVICE_LIST_CACHE_TTL_MS = 5 * 60 * 1000;
 exports.NOOP_MESSAGE_STORE = Object.freeze({
     upsert: async (_record) => { },
+    upsertBatch: async (_records) => { },
     getById: async (_id) => null,
     listByThread: async (_threadJid, _limit, _beforeTimestampMs) => EMPTY_STORE_LIST,
     deleteById: async (_id) => 0,
@@ -13,6 +12,7 @@ exports.NOOP_MESSAGE_STORE = Object.freeze({
 });
 exports.NOOP_THREAD_STORE = Object.freeze({
     upsert: async (_record) => { },
+    upsertBatch: async (_records) => { },
     getByJid: async (_jid) => null,
     list: async (_limit) => EMPTY_STORE_LIST,
     deleteByJid: async (_jid) => 0,
@@ -20,12 +20,12 @@ exports.NOOP_THREAD_STORE = Object.freeze({
 });
 exports.NOOP_CONTACT_STORE = Object.freeze({
     upsert: async (_record) => { },
+    upsertBatch: async (_records) => { },
     getByJid: async (_jid) => null,
     deleteByJid: async (_jid) => 0,
     clear: async () => { }
 });
 exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
-    getTtlMs: () => DEFAULT_PARTICIPANTS_CACHE_TTL_MS,
     upsertGroupParticipants: async (_snapshot) => { },
     getGroupParticipants: async (_groupJid, _nowMs) => null,
     deleteGroupParticipants: async (_groupJid) => 0,
@@ -34,11 +34,8 @@ exports.NOOP_PARTICIPANTS_STORE = Object.freeze({
     destroy: async () => { }
 });
 exports.NOOP_DEVICE_LIST_STORE = Object.freeze({
-    getTtlMs: () => DEFAULT_DEVICE_LIST_CACHE_TTL_MS,
-    upsertUserDevices: async (_snapshot) => { },
     upsertUserDevicesBatch: async (_snapshots) => { },
-    getUserDevices: async (_userJid, _nowMs) => null,
-    getUserDevicesBatch: async (userJids, _nowMs) => userJids.map(() => null),
+    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();
@@ -25,16 +18,21 @@ class WaAppStateMemoryStore {
         this.maxCollectionEntries = (0, coercion_1.resolvePositive)(options.maxCollectionEntries, DEFAULT_APPSTATE_MEMORY_STORE_LIMITS.collectionEntries, 'WaAppStateMemoryStoreOptions.maxCollectionEntries');
         if (initial) {
             for (const key of initial.keys) {
-                (0, collections_1.setBoundedMapEntry)(this.keys, (0, utils_1.keyIdToHex)(key.keyId), key, this.maxSyncKeys);
+                (0, collections_1.setBoundedMapEntry)(this.keys, (0, bytes_1.bytesToHex)(key.keyId), key, this.maxSyncKeys);
             }
             for (const [collectionName, collection] of Object.entries(initial.collections)) {
                 if (!collection) {
                     continue;
                 }
+                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
                 });
             }
         }
@@ -57,7 +55,7 @@ class WaAppStateMemoryStore {
     async upsertSyncKeys(keys) {
         let inserted = 0;
         for (const key of keys) {
-            const keyHex = (0, utils_1.keyIdToHex)(key.keyId);
+            const keyHex = (0, bytes_1.bytesToHex)(key.keyId);
             const existing = this.keys.get(keyHex);
             if (existing && (0, bytes_1.uint8Equal)(existing.keyData, key.keyData)) {
                 continue;
@@ -67,11 +65,22 @@ class WaAppStateMemoryStore {
         }
         return inserted;
     }
-    async getSyncKey(keyId) {
-        return this.keys.get((0, utils_1.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((0, bytes_1.bytesToHex)(keyIds[index])) ?? null;
+        }
+        return keys;
     }
     async getSyncKeyData(keyId) {
-        return this.keys.get((0, utils_1.keyIdToHex)(keyId))?.keyData ?? null;
+        return this.keys.get((0, bytes_1.bytesToHex)(keyId))?.keyData ?? null;
+    }
+    async getSyncKeyDataBatch(keyIds) {
+        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());
@@ -80,6 +89,7 @@ class WaAppStateMemoryStore {
         let state = this.collections.get(collection);
         if (!state) {
             state = {
+                initialized: false,
                 version: 0,
                 hash: constants_1.APP_STATE_EMPTY_LT_HASH,
                 indexValueMap: new Map()
@@ -88,12 +98,24 @@ 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()) {
+                (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/contact.store.js

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

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

@@ -17,54 +17,32 @@ class WaDeviceListMemoryStore {
         }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
         this.cleanupTimer.unref();
     }
-    getTtlMs() {
-        return this.ttlMs;
-    }
-    async upsertUserDevices(snapshot) {
-        (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
-            ...snapshot,
-            expiresAtMs: snapshot.updatedAtMs + this.ttlMs
-        }, this.maxUsers);
-    }
     async upsertUserDevicesBatch(snapshots) {
-        for (const snapshot of snapshots) {
+        for (let index = 0; index < snapshots.length; index += 1) {
+            const snapshot = snapshots[index];
             (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
                 ...snapshot,
                 expiresAtMs: snapshot.updatedAtMs + this.ttlMs
             }, this.maxUsers);
         }
     }
-    async getUserDevices(userJid, nowMs = Date.now()) {
-        const record = this.records.get(userJid);
-        if (!record) {
-            return null;
-        }
-        if (record.expiresAtMs <= nowMs) {
-            this.records.delete(userJid);
-            return null;
-        }
-        return {
-            userJid: record.userJid,
-            deviceJids: record.deviceJids,
-            updatedAtMs: record.updatedAtMs
-        };
-    }
     async getUserDevicesBatch(userJids, nowMs = Date.now()) {
-        return userJids.map((userJid) => {
+        const 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/store/providers/memory/message.store.js

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

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

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

package/dist/store/providers/memory/privacy-token.store.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaPrivacyTokenMemoryStore = void 0;
+const collections_1 = require("../../../util/collections");
+const DEFAULT_MAX_ENTRIES = 10000;
+class WaPrivacyTokenMemoryStore {
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        this.records = new Map();
+        this.maxEntries = maxEntries;
+    }
+    async upsert(record) {
+        const existing = this.records.get(record.jid);
+        const merged = existing ? this.mergeRecord(existing, record) : record;
+        (0, collections_1.setBoundedMapEntry)(this.records, record.jid, merged, this.maxEntries);
+    }
+    async upsertBatch(records) {
+        for (let i = 0; i < records.length; i += 1) {
+            const record = records[i];
+            const existing = this.records.get(record.jid);
+            const merged = existing ? this.mergeRecord(existing, record) : record;
+            (0, collections_1.setBoundedMapEntry)(this.records, record.jid, merged, this.maxEntries);
+        }
+    }
+    async getByJid(jid) {
+        return this.records.get(jid) ?? null;
+    }
+    async deleteByJid(jid) {
+        return this.records.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        this.records.clear();
+    }
+    mergeRecord(existing, incoming) {
+        return {
+            jid: incoming.jid,
+            tcToken: incoming.tcToken ?? existing.tcToken,
+            tcTokenTimestamp: incoming.tcTokenTimestamp ?? existing.tcTokenTimestamp,
+            tcTokenSenderTimestamp: incoming.tcTokenSenderTimestamp ?? existing.tcTokenSenderTimestamp,
+            nctSalt: incoming.nctSalt ?? existing.nctSalt,
+            updatedAtMs: incoming.updatedAtMs
+        };
+    }
+}
+exports.WaPrivacyTokenMemoryStore = WaPrivacyTokenMemoryStore;

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

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaRetryMemoryStore = void 0;
 const collections_1 = require("../../../util/collections");
-const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_RETRY_TTL_MS = 60 * 1000;
 class WaRetryMemoryStore {
     constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
         this.outboundMessages = new Map();
+        this.eligibleSets = new Map();
         this.inboundCounters = new Map();
         this.ttlMs = ttlMs;
         this.cleanupTimer = setInterval(() => {
@@ -16,8 +17,66 @@ class WaRetryMemoryStore {
     getTtlMs() {
         return this.ttlMs;
     }
+    supportsRawReplayPayload() {
+        return true;
+    }
+    async getOutboundRequesterStatus(messageId, requesterDeviceJid) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return null;
+        }
+        const eligible = current.eligibleRequesterDeviceJids;
+        if (!eligible || eligible.length === 0) {
+            return null;
+        }
+        const eligibleSet = this.eligibleSets.get(current.messageId);
+        let isEligible = false;
+        if (eligibleSet) {
+            isEligible = eligibleSet.has(requesterDeviceJid);
+        }
+        else {
+            for (let index = 0; index < eligible.length; index += 1) {
+                if (eligible[index] === requesterDeviceJid) {
+                    isEligible = true;
+                    break;
+                }
+            }
+        }
+        if (!isEligible) {
+            return { eligible: false, delivered: false };
+        }
+        const delivered = current.deliveredRequesterDeviceJids;
+        if (!delivered || delivered.length === 0) {
+            return { eligible: true, delivered: false };
+        }
+        for (let index = 0; index < delivered.length; index += 1) {
+            if (delivered[index] === requesterDeviceJid) {
+                return { eligible: true, delivered: true };
+            }
+        }
+        return { eligible: true, delivered: false };
+    }
     async upsertOutboundMessage(record) {
-        this.outboundMessages.set(record.messageId, record);
+        this.outboundMessages.set(record.messageId, {
+            ...record,
+            eligibleRequesterDeviceJids: record.eligibleRequesterDeviceJids
+                ? [...record.eligibleRequesterDeviceJids]
+                : undefined,
+            deliveredRequesterDeviceJids: record.deliveredRequesterDeviceJids
+                ? [...record.deliveredRequesterDeviceJids]
+                : undefined
+        });
+        if (record.eligibleRequesterDeviceJids && record.eligibleRequesterDeviceJids.length > 0) {
+            this.eligibleSets.set(record.messageId, new Set(record.eligibleRequesterDeviceJids));
+        }
+        else {
+            this.eligibleSets.delete(record.messageId);
+        }
+    }
+    async deleteOutboundMessage(messageId) {
+        const existed = this.outboundMessages.delete(messageId);
+        this.eligibleSets.delete(messageId);
+        return existed ? 1 : 0;
     }
     async getOutboundMessage(messageId) {
         return this.outboundMessages.get(messageId) ?? null;
@@ -34,6 +93,20 @@ class WaRetryMemoryStore {
             expiresAtMs
         });
     }
+    async markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return;
+        }
+        const delivered = new Set(current.deliveredRequesterDeviceJids ?? []);
+        delivered.add(requesterDeviceJid);
+        this.outboundMessages.set(messageId, {
+            ...current,
+            deliveredRequesterDeviceJids: Array.from(delivered),
+            updatedAtMs,
+            expiresAtMs
+        });
+    }
     async incrementInboundCounter(messageId, requesterJid, _updatedAtMs, expiresAtMs) {
         const key = this.counterKey(messageId, requesterJid);
         const current = this.inboundCounters.get(key);
@@ -50,6 +123,7 @@ class WaRetryMemoryStore {
             if (record.expiresAtMs > nowMs)
                 continue;
             this.outboundMessages.delete(messageId);
+            this.eligibleSets.delete(messageId);
             removed += 1;
         }
         for (const [key, record] of this.inboundCounters) {
@@ -62,6 +136,7 @@ class WaRetryMemoryStore {
     }
     async clear() {
         this.outboundMessages.clear();
+        this.eligibleSets.clear();
         this.inboundCounters.clear();
     }
     async destroy() {