zapo-js 0.1.2 → 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

@@ -35,7 +35,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

@@ -27,17 +27,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/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() {

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

@@ -49,7 +49,12 @@ class SenderKeyMemoryStore {
         return record ?? null;
     }
     async getDeviceSenderKeyDistributions(groupId, senders) {
-        return senders.map((sender) => this.senderDistributions.get(this.makeKey(groupId, sender)) ?? null);
+        const records = new Array(senders.length);
+        for (let index = 0; index < senders.length; index += 1) {
+            records[index] =
+                this.senderDistributions.get(this.makeKey(groupId, senders[index])) ?? null;
+        }
+        return records;
     }
     async deleteDeviceSenderKey(target, groupId) {
         let deleted = 0;

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

@@ -61,12 +61,15 @@ class WaSignalMemoryStore {
             throw new Error(`invalid prekey count: ${count}`);
         }
         const available = [];
-        const sortedIds = [...this.preKeys.keys()].sort((left, right) => left - right);
-        for (let index = 0; index < sortedIds.length; index += 1) {
-            const keyId = sortedIds[index];
-            if (this.uploadedPreKeys.has(keyId)) {
-                continue;
+        const availableKeyIds = [];
+        for (const keyId of this.preKeys.keys()) {
+            if (!this.uploadedPreKeys.has(keyId)) {
+                availableKeyIds.push(keyId);
             }
+        }
+        availableKeyIds.sort((left, right) => left - right);
+        for (let index = 0; index < availableKeyIds.length; index += 1) {
+            const keyId = availableKeyIds[index];
             const record = this.preKeys.get(keyId);
             if (!record) {
                 continue;
@@ -89,7 +92,11 @@ class WaSignalMemoryStore {
         return this.preKeys.get(keyId) ?? null;
     }
     async getPreKeysById(keyIds) {
-        return keyIds.map((keyId) => this.preKeys.get(keyId) ?? null);
+        const result = new Array(keyIds.length);
+        for (let i = 0; i < keyIds.length; i += 1) {
+            result[i] = this.preKeys.get(keyIds[i]) ?? null;
+        }
+        return result;
     }
     async consumePreKeyById(keyId) {
         const record = this.preKeys.get(keyId) ?? null;
@@ -120,17 +127,33 @@ class WaSignalMemoryStore {
     async getServerHasPreKeys() {
         return this.serverHasPreKeys;
     }
+    async getSignalMeta() {
+        return {
+            serverHasPreKeys: this.serverHasPreKeys,
+            signedPreKeyRotationTs: this.signedPreKeyRotationTs,
+            registrationInfo: this.registrationInfo,
+            signedPreKey: this.signedPreKey
+        };
+    }
     async hasSession(address) {
         return this.signalSessions.has((0, jid_1.signalAddressKey)(address));
     }
     async hasSessions(addresses) {
-        return addresses.map((address) => this.signalSessions.has((0, jid_1.signalAddressKey)(address)));
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.has((0, jid_1.signalAddressKey)(addresses[i]));
+        }
+        return result;
     }
     async getSession(address) {
         return this.signalSessions.get((0, jid_1.signalAddressKey)(address)) ?? null;
     }
     async getSessionsBatch(addresses) {
-        return addresses.map((address) => this.signalSessions.get((0, jid_1.signalAddressKey)(address)) ?? null);
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.get((0, jid_1.signalAddressKey)(addresses[i])) ?? null;
+        }
+        return result;
     }
     async setSession(address, session) {
         (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(address), session, this.maxSessions);
@@ -148,7 +171,11 @@ class WaSignalMemoryStore {
         return this.remoteIdentities.get((0, jid_1.signalAddressKey)(address)) ?? null;
     }
     async getRemoteIdentities(addresses) {
-        return addresses.map((address) => this.remoteIdentities.get((0, jid_1.signalAddressKey)(address)) ?? null);
+        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);
@@ -170,17 +197,7 @@ class WaSignalMemoryStore {
         this.nextPreKeyId = 1;
     }
     addUploadedPreKey(keyId) {
-        if (this.uploadedPreKeys.has(keyId)) {
-            this.uploadedPreKeys.delete(keyId);
-        }
         this.uploadedPreKeys.add(keyId);
-        while (this.uploadedPreKeys.size > this.maxPreKeys) {
-            const oldest = this.uploadedPreKeys.values().next().value;
-            if (oldest === undefined) {
-                break;
-            }
-            this.uploadedPreKeys.delete(oldest);
-        }
     }
 }
 exports.WaSignalMemoryStore = WaSignalMemoryStore;

package/dist/transport/WaComms.js

@@ -402,7 +402,9 @@ class WaComms {
             this.schedulePendingFramesOverflowClose();
             return false;
         }
-        this.pendingFrames.push(...frames);
+        for (let i = 0; i < frames.length; i += 1) {
+            this.pendingFrames.push(frames[i]);
+        }
         this.pendingFramesByteLength = nextBytes;
         return true;
     }

package/dist/transport/WaWebSocket.js

@@ -129,12 +129,6 @@ class WaWebSocket {
         return (this.socket?.readyState === constants_1.WA_READY_STATES.CONNECTING ||
             this.connectingSockets.size > 0);
     }
-    getReadyState() {
-        if (this.connectingSockets.size > 0) {
-            return constants_1.WA_READY_STATES.CONNECTING;
-        }
-        return this.socket?.readyState ?? constants_1.WA_READY_STATES.CLOSED;
-    }
     async open() {
         if (this.isOpen()) {
             this.logger.trace('socket open skipped: already open');

package/dist/transport/binary/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WAP_DECODE_CONSTANTS = exports.WAP_ENCODE_CONSTANTS = exports.DICTIONARY_TOKEN_MAPS = exports.SINGLE_BYTE_TOKEN_MAP = exports.HEX_ALPHABET = exports.NIBBLE_ALPHABET = exports.NIBBLE_8 = exports.BINARY_32 = exports.BINARY_20 = exports.BINARY_8 = exports.HEX_8 = exports.JID_PAIR = exports.LIST_16 = exports.LIST_8 = exports.JID_U = exports.JID_FB = exports.JID_INTEROP = exports.DICTIONARY_3 = exports.DICTIONARY_0 = exports.STREAM_END = exports.LIST_EMPTY = void 0;
+exports.DICTIONARY_TOKEN_MAPS = exports.SINGLE_BYTE_TOKEN_MAP = exports.HEX_ALPHABET = exports.NIBBLE_ALPHABET = exports.NIBBLE_8 = exports.BINARY_32 = exports.BINARY_20 = exports.BINARY_8 = exports.HEX_8 = exports.JID_PAIR = exports.LIST_16 = exports.LIST_8 = exports.JID_U = exports.JID_FB = exports.JID_INTEROP = exports.DICTIONARY_3 = exports.DICTIONARY_0 = exports.STREAM_END = exports.LIST_EMPTY = void 0;
 const tokens_1 = require("../binary/tokens");
 exports.LIST_EMPTY = 0;
 exports.STREAM_END = 2;
@@ -67,33 +67,3 @@ exports.DICTIONARY_TOKEN_MAPS = tokens_1.DICTIONARIES.map((dictionary) => {
     }
     return map;
 });
-exports.WAP_ENCODE_CONSTANTS = Object.freeze({
-    LIST_EMPTY: exports.LIST_EMPTY,
-    LIST_8: exports.LIST_8,
-    LIST_16: exports.LIST_16,
-    JID_PAIR: exports.JID_PAIR,
-    HEX_8: exports.HEX_8,
-    BINARY_8: exports.BINARY_8,
-    BINARY_20: exports.BINARY_20,
-    BINARY_32: exports.BINARY_32,
-    NIBBLE_8: exports.NIBBLE_8,
-    DICTIONARY_0: exports.DICTIONARY_0,
-    DICTIONARY_3: exports.DICTIONARY_3
-});
-exports.WAP_DECODE_CONSTANTS = Object.freeze({
-    LIST_EMPTY: exports.LIST_EMPTY,
-    LIST_8: exports.LIST_8,
-    LIST_16: exports.LIST_16,
-    JID_PAIR: exports.JID_PAIR,
-    JID_FB: exports.JID_FB,
-    JID_INTEROP: exports.JID_INTEROP,
-    JID_U: exports.JID_U,
-    HEX_8: exports.HEX_8,
-    BINARY_8: exports.BINARY_8,
-    BINARY_20: exports.BINARY_20,
-    BINARY_32: exports.BINARY_32,
-    NIBBLE_8: exports.NIBBLE_8,
-    DICTIONARY_0: exports.DICTIONARY_0,
-    DICTIONARY_3: exports.DICTIONARY_3,
-    STREAM_END: exports.STREAM_END
-});