zapo-js 0.1.0

package/dist/esm/store/noop.store.js

@@ -0,0 +1,43 @@
+const EMPTY_STORE_LIST = Object.freeze([]);
+const DEFAULT_PARTICIPANTS_CACHE_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_DEVICE_LIST_CACHE_TTL_MS = 5 * 60 * 1000;
+export const NOOP_MESSAGE_STORE = Object.freeze({
+    upsert: async (_record) => { },
+    getById: async (_id) => null,
+    listByThread: async (_threadJid, _limit, _beforeTimestampMs) => EMPTY_STORE_LIST,
+    deleteById: async (_id) => 0,
+    clear: async () => { }
+});
+export const NOOP_THREAD_STORE = Object.freeze({
+    upsert: async (_record) => { },
+    getByJid: async (_jid) => null,
+    list: async (_limit) => EMPTY_STORE_LIST,
+    deleteByJid: async (_jid) => 0,
+    clear: async () => { }
+});
+export const NOOP_CONTACT_STORE = Object.freeze({
+    upsert: async (_record) => { },
+    getByJid: async (_jid) => null,
+    deleteByJid: async (_jid) => 0,
+    clear: async () => { }
+});
+export const NOOP_PARTICIPANTS_STORE = Object.freeze({
+    getTtlMs: () => DEFAULT_PARTICIPANTS_CACHE_TTL_MS,
+    upsertGroupParticipants: async (_snapshot) => { },
+    getGroupParticipants: async (_groupJid, _nowMs) => null,
+    deleteGroupParticipants: async (_groupJid) => 0,
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { },
+    destroy: async () => { }
+});
+export const NOOP_DEVICE_LIST_STORE = Object.freeze({
+    getTtlMs: () => DEFAULT_DEVICE_LIST_CACHE_TTL_MS,
+    upsertUserDevices: async (_snapshot) => { },
+    upsertUserDevicesBatch: async (_snapshots) => { },
+    getUserDevices: async (_userJid, _nowMs) => null,
+    getUserDevicesBatch: async (userJids, _nowMs) => userJids.map(() => null),
+    deleteUserDevices: async (_userJid) => 0,
+    cleanupExpired: async (_nowMs) => 0,
+    clear: async () => { },
+    destroy: async () => { }
+});

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

@@ -0,0 +1,101 @@
+import { APP_STATE_EMPTY_LT_HASH } from '../../../appstate/constants.js';
+import { keyIdToHex, pickActiveSyncKey } from '../../../appstate/utils.js';
+import { uint8Equal } from '../../../util/bytes.js';
+import { resolvePositive } from '../../../util/coercion.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_APPSTATE_MEMORY_STORE_LIMITS = Object.freeze({
+    syncKeys: 4096,
+    collectionEntries: 50000
+});
+function toBoundedMap(entries, maxEntries) {
+    const map = new Map();
+    for (const [key, value] of entries) {
+        setBoundedMapEntry(map, key, value, maxEntries);
+    }
+    return map;
+}
+export class WaAppStateMemoryStore {
+    constructor(initial, options = {}) {
+        this.keys = new Map();
+        this.collections = new Map();
+        this.maxSyncKeys = resolvePositive(options.maxSyncKeys, DEFAULT_APPSTATE_MEMORY_STORE_LIMITS.syncKeys, 'WaAppStateMemoryStoreOptions.maxSyncKeys');
+        this.maxCollectionEntries = resolvePositive(options.maxCollectionEntries, DEFAULT_APPSTATE_MEMORY_STORE_LIMITS.collectionEntries, 'WaAppStateMemoryStoreOptions.maxCollectionEntries');
+        if (initial) {
+            for (const key of initial.keys) {
+                setBoundedMapEntry(this.keys, keyIdToHex(key.keyId), key, this.maxSyncKeys);
+            }
+            for (const [collectionName, collection] of Object.entries(initial.collections)) {
+                if (!collection) {
+                    continue;
+                }
+                this.collections.set(collectionName, {
+                    version: collection.version,
+                    hash: collection.hash,
+                    indexValueMap: toBoundedMap(Object.entries(collection.indexValueMap), this.maxCollectionEntries)
+                });
+            }
+        }
+    }
+    async exportData() {
+        const keys = Array.from(this.keys.values());
+        const collections = {};
+        for (const [collection, state] of this.collections.entries()) {
+            collections[collection] = {
+                version: state.version,
+                hash: state.hash,
+                indexValueMap: Object.fromEntries(state.indexValueMap.entries())
+            };
+        }
+        return {
+            keys,
+            collections
+        };
+    }
+    async upsertSyncKeys(keys) {
+        let inserted = 0;
+        for (const key of keys) {
+            const keyHex = keyIdToHex(key.keyId);
+            const existing = this.keys.get(keyHex);
+            if (existing && uint8Equal(existing.keyData, key.keyData)) {
+                continue;
+            }
+            setBoundedMapEntry(this.keys, keyHex, key, this.maxSyncKeys);
+            inserted += 1;
+        }
+        return inserted;
+    }
+    async getSyncKey(keyId) {
+        return this.keys.get(keyIdToHex(keyId)) ?? null;
+    }
+    async getSyncKeyData(keyId) {
+        return this.keys.get(keyIdToHex(keyId))?.keyData ?? null;
+    }
+    async getActiveSyncKey() {
+        return pickActiveSyncKey(this.keys.values());
+    }
+    async getCollectionState(collection) {
+        let state = this.collections.get(collection);
+        if (!state) {
+            state = {
+                version: 0,
+                hash: APP_STATE_EMPTY_LT_HASH,
+                indexValueMap: new Map()
+            };
+            this.collections.set(collection, state);
+        }
+        return state;
+    }
+    async setCollectionStates(updates) {
+        for (const update of updates) {
+            this.collections.set(update.collection, {
+                version: update.version,
+                hash: update.hash,
+                indexValueMap: toBoundedMap(update.indexValueMap.entries(), this.maxCollectionEntries)
+            });
+        }
+    }
+    async clear() {
+        this.keys.clear();
+        this.collections.clear();
+    }
+}

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

@@ -0,0 +1,23 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_CONTACT_MEMORY_STORE_LIMITS = Object.freeze({
+    contacts: 20000
+});
+export class WaContactMemoryStore {
+    constructor(options = {}) {
+        this.contacts = new Map();
+        this.maxContacts = resolvePositive(options.maxContacts, DEFAULT_CONTACT_MEMORY_STORE_LIMITS.contacts, 'WaContactMemoryStoreOptions.maxContacts');
+    }
+    async upsert(record) {
+        setBoundedMapEntry(this.contacts, record.jid, record, this.maxContacts);
+    }
+    async getByJid(jid) {
+        return this.contacts.get(jid) ?? null;
+    }
+    async deleteByJid(jid) {
+        return this.contacts.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.contacts.clear();
+    }
+}

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

@@ -0,0 +1,86 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    maxUsers: 16384
+});
+export class WaDeviceListMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        this.records = new Map();
+        this.ttlMs = ttlMs;
+        this.maxUsers = resolvePositive(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, resolveCleanupIntervalMs(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    getTtlMs() {
+        return this.ttlMs;
+    }
+    async upsertUserDevices(snapshot) {
+        setBoundedMapEntry(this.records, snapshot.userJid, {
+            ...snapshot,
+            expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+        }, this.maxUsers);
+    }
+    async upsertUserDevicesBatch(snapshots) {
+        for (const snapshot of snapshots) {
+            setBoundedMapEntry(this.records, snapshot.userJid, {
+                ...snapshot,
+                expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+            }, this.maxUsers);
+        }
+    }
+    async getUserDevices(userJid, nowMs = Date.now()) {
+        const record = this.records.get(userJid);
+        if (!record) {
+            return null;
+        }
+        if (record.expiresAtMs <= nowMs) {
+            this.records.delete(userJid);
+            return null;
+        }
+        return {
+            userJid: record.userJid,
+            deviceJids: record.deviceJids,
+            updatedAtMs: record.updatedAtMs
+        };
+    }
+    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
+        return userJids.map((userJid) => {
+            const record = this.records.get(userJid);
+            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 deleteUserDevices(userJid) {
+        return this.records.delete(userJid) ? 1 : 0;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [userJid, record] of this.records) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.records.delete(userJid);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        await this.clear();
+    }
+}

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

@@ -0,0 +1,40 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { normalizeQueryLimit } from '../../../util/collections.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULT_MESSAGE_MEMORY_STORE_LIMITS = Object.freeze({
+    messages: 50000
+});
+export class WaMessageMemoryStore {
+    constructor(options = {}) {
+        this.messages = new Map();
+        this.maxMessages = resolvePositive(options.maxMessages, DEFAULT_MESSAGE_MEMORY_STORE_LIMITS.messages, 'WaMessageMemoryStoreOptions.maxMessages');
+    }
+    async upsert(record) {
+        setBoundedMapEntry(this.messages, record.id, record, this.maxMessages);
+    }
+    async getById(id) {
+        return this.messages.get(id) ?? null;
+    }
+    async listByThread(threadJid, limit, beforeTimestampMs) {
+        const normalizedLimit = normalizeQueryLimit(limit, 50);
+        const records = [];
+        for (const record of this.messages.values()) {
+            if (record.threadJid !== threadJid) {
+                continue;
+            }
+            if (beforeTimestampMs !== undefined &&
+                (record.timestampMs === undefined || record.timestampMs >= beforeTimestampMs)) {
+                continue;
+            }
+            records.push(record);
+        }
+        records.sort((left, right) => (right.timestampMs ?? 0) - (left.timestampMs ?? 0));
+        return records.length <= normalizedLimit ? records : records.slice(0, normalizedLimit);
+    }
+    async deleteById(id) {
+        return this.messages.delete(id) ? 1 : 0;
+    }
+    async clear() {
+        this.messages.clear();
+    }
+}

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

@@ -0,0 +1,61 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    maxGroups: 4096
+});
+export class WaParticipantsMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        this.records = new Map();
+        this.ttlMs = ttlMs;
+        this.maxGroups = resolvePositive(options.maxGroups, DEFAULTS.maxGroups, 'WaParticipantsMemoryStoreOptions.maxGroups');
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, resolveCleanupIntervalMs(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    getTtlMs() {
+        return this.ttlMs;
+    }
+    async upsertGroupParticipants(snapshot) {
+        setBoundedMapEntry(this.records, snapshot.groupJid, {
+            ...snapshot,
+            expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+        }, this.maxGroups);
+    }
+    async getGroupParticipants(groupJid, nowMs = Date.now()) {
+        const record = this.records.get(groupJid);
+        if (!record) {
+            return null;
+        }
+        if (record.expiresAtMs <= nowMs) {
+            this.records.delete(groupJid);
+            return null;
+        }
+        return {
+            groupJid: record.groupJid,
+            participants: record.participants,
+            updatedAtMs: record.updatedAtMs
+        };
+    }
+    async deleteGroupParticipants(groupJid) {
+        return this.records.delete(groupJid) ? 1 : 0;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [groupJid, record] of this.records) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.records.delete(groupJid);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        await this.clear();
+    }
+}

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

@@ -0,0 +1,71 @@
+import { resolveCleanupIntervalMs } from '../../../util/collections.js';
+const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+export class WaRetryMemoryStore {
+    constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
+        this.outboundMessages = new Map();
+        this.inboundCounters = new Map();
+        this.ttlMs = ttlMs;
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, resolveCleanupIntervalMs(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    getTtlMs() {
+        return this.ttlMs;
+    }
+    async upsertOutboundMessage(record) {
+        this.outboundMessages.set(record.messageId, record);
+    }
+    async getOutboundMessage(messageId) {
+        return this.outboundMessages.get(messageId) ?? null;
+    }
+    async updateOutboundMessageState(messageId, state, updatedAtMs, expiresAtMs) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return;
+        }
+        this.outboundMessages.set(messageId, {
+            ...current,
+            state,
+            updatedAtMs,
+            expiresAtMs
+        });
+    }
+    async incrementInboundCounter(messageId, requesterJid, _updatedAtMs, expiresAtMs) {
+        const key = this.counterKey(messageId, requesterJid);
+        const current = this.inboundCounters.get(key);
+        const count = current ? current.count + 1 : 1;
+        this.inboundCounters.set(key, {
+            count,
+            expiresAtMs
+        });
+        return count;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [messageId, record] of this.outboundMessages) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.outboundMessages.delete(messageId);
+            removed += 1;
+        }
+        for (const [key, record] of this.inboundCounters) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.inboundCounters.delete(key);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.outboundMessages.clear();
+        this.inboundCounters.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        await this.clear();
+    }
+    counterKey(messageId, requesterJid) {
+        return `${messageId}|${requesterJid}`;
+    }
+}

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

@@ -0,0 +1,88 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+import { signalAddressKey } from '../../../util/signal-address.js';
+const DEFAULT_SENDER_KEY_STORE_LIMITS = Object.freeze({
+    senderKeys: 8192,
+    senderDistributions: 8192
+});
+export class SenderKeyMemoryStore {
+    constructor(options = {}) {
+        this.senderKeys = new Map();
+        this.senderDistributions = new Map();
+        this.maxSenderKeys = resolvePositive(options.maxSenderKeys, DEFAULT_SENDER_KEY_STORE_LIMITS.senderKeys, 'WaSenderKeyMemoryStoreOptions.maxSenderKeys');
+        this.maxSenderDistributions = resolvePositive(options.maxSenderDistributions, DEFAULT_SENDER_KEY_STORE_LIMITS.senderDistributions, 'WaSenderKeyMemoryStoreOptions.maxSenderDistributions');
+    }
+    async upsertSenderKey(record) {
+        setBoundedMapEntry(this.senderKeys, this.makeKey(record.groupId, record.sender), record, this.maxSenderKeys);
+    }
+    async upsertSenderKeyDistribution(record) {
+        setBoundedMapEntry(this.senderDistributions, this.makeKey(record.groupId, record.sender), record, this.maxSenderDistributions);
+    }
+    async upsertSenderKeyDistributions(records) {
+        for (const record of records) {
+            setBoundedMapEntry(this.senderDistributions, this.makeKey(record.groupId, record.sender), record, this.maxSenderDistributions);
+        }
+    }
+    async getGroupSenderKeyList(groupId) {
+        const skList = [];
+        const skDistribList = [];
+        for (const record of this.senderKeys.values()) {
+            if (record.groupId === groupId) {
+                skList.push(record);
+            }
+        }
+        for (const record of this.senderDistributions.values()) {
+            if (record.groupId === groupId) {
+                skDistribList.push(record);
+            }
+        }
+        return {
+            skList,
+            skDistribList
+        };
+    }
+    async getDeviceSenderKey(groupId, sender) {
+        const record = this.senderKeys.get(this.makeKey(groupId, sender));
+        return record ?? null;
+    }
+    async getDeviceSenderKeyDistribution(groupId, sender) {
+        const record = this.senderDistributions.get(this.makeKey(groupId, sender));
+        return record ?? null;
+    }
+    async getDeviceSenderKeyDistributions(groupId, senders) {
+        return senders.map((sender) => this.senderDistributions.get(this.makeKey(groupId, sender)) ?? null);
+    }
+    async deleteDeviceSenderKey(target, groupId) {
+        let deleted = 0;
+        deleted += this.deleteMatching(this.senderKeys, target, groupId);
+        deleted += this.deleteMatching(this.senderDistributions, target, groupId);
+        return deleted;
+    }
+    async markForgetSenderKey(groupId, participants) {
+        let deleted = 0;
+        for (const participant of participants) {
+            deleted += await this.deleteDeviceSenderKey(participant, groupId);
+        }
+        return deleted;
+    }
+    async clear() {
+        this.senderKeys.clear();
+        this.senderDistributions.clear();
+    }
+    deleteMatching(map, target, groupId) {
+        let deleted = 0;
+        const targetAddressKey = signalAddressKey(target);
+        for (const [key, record] of map.entries()) {
+            const sameGroup = groupId ? record.groupId === groupId : true;
+            const sameAddress = signalAddressKey(record.sender) === targetAddressKey;
+            if (sameGroup && sameAddress) {
+                map.delete(key);
+                deleted += 1;
+            }
+        }
+        return deleted;
+    }
+    makeKey(groupId, sender) {
+        return `${groupId}|${signalAddressKey(sender)}`;
+    }
+}

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

@@ -0,0 +1,170 @@
+import { resolvePositive } from '../../../util/coercion.js';
+import { setBoundedMapEntry } from '../../../util/collections.js';
+import { signalAddressKey } from '../../../util/signal-address.js';
+const DEFAULT_SIGNAL_STORE_LIMITS = Object.freeze({
+    preKeys: 4096,
+    sessions: 8192,
+    remoteIdentities: 8192
+});
+export class WaSignalMemoryStore {
+    constructor(options = {}) {
+        this.registrationInfo = null;
+        this.signedPreKey = null;
+        this.signedPreKeyRotationTs = null;
+        this.preKeys = new Map();
+        this.uploadedPreKeys = new Set();
+        this.serverHasPreKeys = false;
+        this.signalSessions = new Map();
+        this.remoteIdentities = new Map();
+        this.nextPreKeyId = 1;
+        this.maxPreKeys = resolvePositive(options.maxPreKeys, DEFAULT_SIGNAL_STORE_LIMITS.preKeys, 'WaSignalMemoryStoreOptions.maxPreKeys');
+        this.maxSessions = resolvePositive(options.maxSessions, DEFAULT_SIGNAL_STORE_LIMITS.sessions, 'WaSignalMemoryStoreOptions.maxSessions');
+        this.maxRemoteIdentities = resolvePositive(options.maxRemoteIdentities, DEFAULT_SIGNAL_STORE_LIMITS.remoteIdentities, 'WaSignalMemoryStoreOptions.maxRemoteIdentities');
+    }
+    async getRegistrationInfo() {
+        return this.registrationInfo;
+    }
+    async setRegistrationInfo(info) {
+        this.registrationInfo = info;
+    }
+    async getSignedPreKey() {
+        return this.signedPreKey;
+    }
+    async setSignedPreKey(record) {
+        this.signedPreKey = record;
+    }
+    async getSignedPreKeyById(keyId) {
+        if (!this.signedPreKey) {
+            return null;
+        }
+        return this.signedPreKey.keyId === keyId ? this.signedPreKey : null;
+    }
+    async setSignedPreKeyRotationTs(value) {
+        this.signedPreKeyRotationTs = value;
+    }
+    async getSignedPreKeyRotationTs() {
+        return this.signedPreKeyRotationTs;
+    }
+    async putPreKey(record) {
+        setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+            this.uploadedPreKeys.delete(keyId);
+        });
+        if (record.keyId >= this.nextPreKeyId) {
+            this.nextPreKeyId = record.keyId + 1;
+        }
+    }
+    async getOrGenPreKeys(count, generator) {
+        if (!Number.isSafeInteger(count) || count <= 0) {
+            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 record = this.preKeys.get(keyId);
+            if (!record) {
+                continue;
+            }
+            available.push(record);
+            if (available.length >= count) {
+                return available;
+            }
+        }
+        while (available.length < count) {
+            const record = await generator(this.nextPreKeyId++);
+            setBoundedMapEntry(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+                this.uploadedPreKeys.delete(keyId);
+            });
+            available.push(record);
+        }
+        return available;
+    }
+    async getPreKeyById(keyId) {
+        return this.preKeys.get(keyId) ?? null;
+    }
+    async getPreKeysById(keyIds) {
+        return keyIds.map((keyId) => this.preKeys.get(keyId) ?? null);
+    }
+    async consumePreKeyById(keyId) {
+        const record = this.preKeys.get(keyId) ?? null;
+        if (!record) {
+            return null;
+        }
+        this.preKeys.delete(keyId);
+        this.uploadedPreKeys.delete(keyId);
+        return record;
+    }
+    async getOrGenSinglePreKey(generator) {
+        const preKeys = await this.getOrGenPreKeys(1, generator);
+        return preKeys[0];
+    }
+    async markKeyAsUploaded(keyId) {
+        if (keyId < 0 || keyId >= this.nextPreKeyId) {
+            throw new Error(`prekey ${keyId} is out of boundary`);
+        }
+        for (const candidate of this.preKeys.keys()) {
+            if (candidate <= keyId) {
+                this.addUploadedPreKey(candidate);
+            }
+        }
+    }
+    async setServerHasPreKeys(value) {
+        this.serverHasPreKeys = value;
+    }
+    async getServerHasPreKeys() {
+        return this.serverHasPreKeys;
+    }
+    async hasSession(address) {
+        return this.signalSessions.has(signalAddressKey(address));
+    }
+    async hasSessions(addresses) {
+        return addresses.map((address) => this.signalSessions.has(signalAddressKey(address)));
+    }
+    async getSession(address) {
+        return this.signalSessions.get(signalAddressKey(address)) ?? null;
+    }
+    async setSession(address, session) {
+        setBoundedMapEntry(this.signalSessions, signalAddressKey(address), session, this.maxSessions);
+    }
+    async deleteSession(address) {
+        this.signalSessions.delete(signalAddressKey(address));
+    }
+    async getRemoteIdentity(address) {
+        return this.remoteIdentities.get(signalAddressKey(address)) ?? null;
+    }
+    async setRemoteIdentity(address, identityKey) {
+        setBoundedMapEntry(this.remoteIdentities, signalAddressKey(address), identityKey, this.maxRemoteIdentities);
+    }
+    async setRemoteIdentities(entries) {
+        for (const entry of entries) {
+            setBoundedMapEntry(this.remoteIdentities, signalAddressKey(entry.address), entry.identityKey, this.maxRemoteIdentities);
+        }
+    }
+    async clear() {
+        this.registrationInfo = null;
+        this.signedPreKey = null;
+        this.signedPreKeyRotationTs = null;
+        this.preKeys.clear();
+        this.uploadedPreKeys.clear();
+        this.serverHasPreKeys = false;
+        this.signalSessions.clear();
+        this.remoteIdentities.clear();
+        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);
+        }
+    }
+}