zapo-js 0.1.1 → 0.2.0

package/dist/esm/client/messaging/fanout.js

@@ -0,0 +1,196 @@
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { isHostedDeviceJid, normalizeDeviceJid, splitJid, toUserJid } from '../../protocol/jid.js';
+import { toError } from '../../util/primitives.js';
+export function createDeviceFanoutResolver(options) {
+    const { signalDeviceSync, getCurrentMeJid, getCurrentMeLid, logger } = options;
+    const dedup = new PromiseDedup();
+    const resolveDirectFanoutDeviceJids = async (recipientJid, selfDeviceJidForRecipient) => {
+        const recipientUserJid = toUserJid(recipientJid);
+        const meUserJid = toUserJid(selfDeviceJidForRecipient);
+        const targets = recipientUserJid === meUserJid ? [recipientUserJid] : [recipientUserJid, meUserJid];
+        try {
+            const synced = await signalDeviceSync.syncDeviceList(targets);
+            const byUser = new Map();
+            for (let index = 0; index < synced.length; index += 1) {
+                const entry = synced[index];
+                byUser.set(toUserJid(entry.jid), entry.deviceJids);
+            }
+            const fanout = new Set();
+            const recipientDevices = byUser.get(recipientUserJid) ?? [];
+            if (recipientDevices.length === 0) {
+                fanout.add(recipientUserJid);
+            }
+            else {
+                for (let index = 0; index < recipientDevices.length; index += 1) {
+                    fanout.add(recipientDevices[index]);
+                }
+            }
+            const meDevices = byUser.get(meUserJid) ?? [];
+            const normalizedMeJid = normalizeDeviceJid(selfDeviceJidForRecipient);
+            for (let index = 0; index < meDevices.length; index += 1) {
+                const deviceJid = meDevices[index];
+                if (normalizeDeviceJid(deviceJid) === normalizedMeJid) {
+                    continue;
+                }
+                fanout.add(deviceJid);
+            }
+            return [...fanout];
+        }
+        catch (error) {
+            logger.warn('signal device fanout sync failed, falling back to direct recipient', {
+                to: recipientJid,
+                message: toError(error).message
+            });
+            return [recipientUserJid];
+        }
+    };
+    const resolveGroupParticipantDeviceJidsInternal = async (participantUserJids) => {
+        const meDeviceJids = new Set();
+        const meJid = getCurrentMeJid();
+        if (meJid) {
+            try {
+                meDeviceJids.add(normalizeDeviceJid(meJid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me jid', {
+                    meJid,
+                    message: toError(error).message
+                });
+            }
+        }
+        const meLid = getCurrentMeLid();
+        if (meLid && meLid.includes('@')) {
+            try {
+                meDeviceJids.add(normalizeDeviceJid(meLid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me lid jid', {
+                    meLid,
+                    message: toError(error).message
+                });
+            }
+        }
+        const candidateUserSet = new Set();
+        for (let index = 0; index < participantUserJids.length; index += 1) {
+            candidateUserSet.add(participantUserJids[index]);
+        }
+        const candidateUsers = Array.from(candidateUserSet);
+        if (candidateUsers.length === 0) {
+            return [];
+        }
+        try {
+            const synced = await signalDeviceSync.syncDeviceList(candidateUsers);
+            const fanout = new Set();
+            for (const entry of synced) {
+                if (entry.deviceJids.length === 0) {
+                    const normalizedEntryJid = normalizeDeviceJid(entry.jid);
+                    if (meDeviceJids.has(normalizedEntryJid)) {
+                        continue;
+                    }
+                    fanout.add(normalizedEntryJid);
+                    continue;
+                }
+                for (const deviceJid of entry.deviceJids) {
+                    const normalizedDeviceJid = normalizeDeviceJid(deviceJid);
+                    if (isHostedDeviceJid(normalizedDeviceJid)) {
+                        continue;
+                    }
+                    if (meDeviceJids.has(normalizedDeviceJid)) {
+                        continue;
+                    }
+                    fanout.add(normalizedDeviceJid);
+                }
+            }
+            return [...fanout];
+        }
+        catch (error) {
+            logger.warn('group participant device sync failed, falling back to participant user jids', {
+                participants: candidateUsers.length,
+                message: toError(error).message
+            });
+            const fallbackJids = new Set();
+            for (const candidateJid of candidateUsers) {
+                try {
+                    const normalizedCandidateJid = normalizeDeviceJid(candidateJid);
+                    if (meDeviceJids.has(normalizedCandidateJid)) {
+                        continue;
+                    }
+                    fallbackJids.add(normalizedCandidateJid);
+                }
+                catch (fallbackError) {
+                    logger.trace('ignoring malformed participant jid in fallback fanout resolution', {
+                        participantJid: candidateJid,
+                        message: toError(fallbackError).message
+                    });
+                }
+            }
+            return [...fallbackJids];
+        }
+    };
+    const resolveOwnPeerDeviceJids = async () => {
+        const meJid = getCurrentMeJid();
+        if (!meJid) {
+            throw new Error('resolveOwnPeerDeviceJids requires registered meJid');
+        }
+        const meUserJid = toUserJid(meJid);
+        const meDevices = new Set();
+        meDevices.add(normalizeDeviceJid(meJid));
+        const meLid = getCurrentMeLid();
+        if (meLid && meLid.includes('@')) {
+            try {
+                meDevices.add(normalizeDeviceJid(meLid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me lid jid while resolving peer devices', {
+                    meLid,
+                    message: toError(error).message
+                });
+            }
+        }
+        try {
+            const synced = await signalDeviceSync.syncDeviceList([meUserJid]);
+            const peerDevices = new Set();
+            for (const entry of synced) {
+                const sourceDevices = entry.deviceJids.length > 0 ? entry.deviceJids : [entry.jid];
+                for (const deviceJid of sourceDevices) {
+                    try {
+                        const normalized = normalizeDeviceJid(deviceJid);
+                        if (meDevices.has(normalized)) {
+                            continue;
+                        }
+                        peerDevices.add(normalized);
+                    }
+                    catch (error) {
+                        logger.trace('ignoring malformed peer device jid while resolving app-state peers', {
+                            deviceJid,
+                            message: toError(error).message
+                        });
+                    }
+                }
+            }
+            return [...peerDevices];
+        }
+        catch (error) {
+            logger.warn('failed to resolve peer devices for app-state key request', {
+                message: toError(error).message
+            });
+            return [];
+        }
+    };
+    const resolveSelfDeviceJidForRecipient = (recipientJid, meJid, meLid) => {
+        if (splitJid(recipientJid).server !== 'lid') {
+            return meJid;
+        }
+        if (!meLid || !meLid.includes('@')) {
+            return meJid;
+        }
+        return meLid;
+    };
+    const resolveGroupParticipantDeviceJids = (participantUserJids) => dedup.run(`group:${participantUserJids.join(',')}`, () => resolveGroupParticipantDeviceJidsInternal(participantUserJids));
+    return {
+        resolveDirectFanoutDeviceJids,
+        resolveGroupParticipantDeviceJids,
+        resolveOwnPeerDeviceJids,
+        resolveSelfDeviceJidForRecipient
+    };
+}

package/dist/esm/client/messaging/key-protocol.js

@@ -0,0 +1,127 @@
+import { writeRandomPadMax16 } from '../../message/padding.js';
+import { proto } from '../../proto.js';
+import { normalizeDeviceJid } from '../../protocol/jid.js';
+import { bytesToHex } from '../../util/bytes.js';
+export function createAppStateSyncKeyProtocol(options) {
+    const { publishSignalMessage, fanoutResolver, getCurrentMeJid, getCurrentMeLid, logger } = options;
+    const requireCurrentIdentity = (context) => {
+        const meJid = getCurrentMeJid();
+        const meLid = getCurrentMeLid();
+        if (meJid || meLid) {
+            return;
+        }
+        throw new Error(`${context} requires registered identity`);
+    };
+    const publishProtocolMessageToDevice = async (deviceJid, protocolMessage) => {
+        const plaintext = await writeRandomPadMax16(proto.Message.encode({
+            protocolMessage
+        }).finish());
+        await publishSignalMessage({
+            to: deviceJid,
+            plaintext,
+            type: 'protocol',
+            category: 'peer',
+            pushPriority: 'high'
+        });
+    };
+    const requestKeys = async (keyIds) => {
+        requireCurrentIdentity('requestKeys');
+        const normalizedKeyIds = [];
+        const seenKeyIds = new Set();
+        for (const keyId of keyIds) {
+            if (keyId.byteLength === 0) {
+                continue;
+            }
+            const keyHex = bytesToHex(keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            normalizedKeyIds.push(keyId);
+        }
+        if (normalizedKeyIds.length === 0) {
+            return [];
+        }
+        const peerDeviceJids = await fanoutResolver.resolveOwnPeerDeviceJids();
+        if (peerDeviceJids.length === 0) {
+            logger.warn('app-state sync key request skipped: no peer devices available', {
+                keys: normalizedKeyIds.length
+            });
+            return [];
+        }
+        const protocolMessage = {
+            type: proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST,
+            appStateSyncKeyRequest: {
+                keyIds: normalizedKeyIds.map((keyId) => ({
+                    keyId
+                }))
+            }
+        };
+        const publishResults = await Promise.allSettled(peerDeviceJids.map((deviceJid) => publishProtocolMessageToDevice(deviceJid, protocolMessage)));
+        const failedPublishes = publishResults.filter((result) => result.status === 'rejected').length;
+        if (failedPublishes > 0) {
+            logger.warn('some app-state sync key requests failed', {
+                total: peerDeviceJids.length,
+                failed: failedPublishes
+            });
+        }
+        logger.info('app-state sync key request sent to peer devices', {
+            devices: peerDeviceJids.length,
+            keys: normalizedKeyIds.length,
+            keyIds: normalizedKeyIds.map((keyId) => bytesToHex(keyId)).join(',')
+        });
+        return peerDeviceJids;
+    };
+    const sendKeyShare = async (toDeviceJid, keys, missingKeyIds = []) => {
+        requireCurrentIdentity('sendKeyShare');
+        const normalizedTo = normalizeDeviceJid(toDeviceJid);
+        const seenKeyIds = new Set();
+        const keyShareEntries = [];
+        let sharedKeyCount = 0;
+        for (const key of keys) {
+            const keyHex = bytesToHex(key.keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            sharedKeyCount += 1;
+            keyShareEntries.push({
+                keyId: { keyId: key.keyId },
+                keyData: {
+                    keyData: key.keyData,
+                    timestamp: key.timestamp,
+                    ...(key.fingerprint ? { fingerprint: key.fingerprint } : {})
+                }
+            });
+        }
+        for (const keyId of missingKeyIds) {
+            if (keyId.byteLength === 0) {
+                continue;
+            }
+            const keyHex = bytesToHex(keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            keyShareEntries.push({
+                keyId: { keyId }
+            });
+        }
+        const protocolMessage = {
+            type: proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE,
+            appStateSyncKeyShare: {
+                keys: keyShareEntries
+            }
+        };
+        await publishProtocolMessageToDevice(normalizedTo, protocolMessage);
+        logger.info('app-state sync key share sent', {
+            to: normalizedTo,
+            keys: sharedKeyCount,
+            orphanKeys: keyShareEntries.length - sharedKeyCount
+        });
+    };
+    return {
+        requestKeys,
+        sendKeyShare
+    };
+}

package/dist/esm/client/messaging/participants.js

@@ -0,0 +1,190 @@
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { toUserJid } from '../../protocol/jid.js';
+import { toError } from '../../util/primitives.js';
+export function createGroupParticipantsCache(options) {
+    const { participantsStore, queryGroupParticipantJids, logger } = options;
+    const dedup = new PromiseDedup();
+    const sanitizeParticipantUsers = (participants) => {
+        const deduped = new Set();
+        for (const participant of participants) {
+            if (!participant || !participant.includes('@')) {
+                continue;
+            }
+            try {
+                deduped.add(toUserJid(participant));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed participant jid', {
+                    participant,
+                    message: toError(error).message
+                });
+            }
+        }
+        return [...deduped];
+    };
+    const areParticipantListsEqual = (left, right) => {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (left[index] !== right[index]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    const mergeParticipantUsersIntoCache = async (groupJid, cachedParticipants, participantsToAdd) => {
+        if (participantsToAdd.length === 0) {
+            return;
+        }
+        const nextParticipants = [...cachedParticipants];
+        const existing = new Set(cachedParticipants);
+        for (const participant of participantsToAdd) {
+            if (existing.has(participant)) {
+                continue;
+            }
+            existing.add(participant);
+            nextParticipants.push(participant);
+        }
+        if (nextParticipants.length === cachedParticipants.length) {
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const removeParticipantUsersFromCache = async (groupJid, cachedParticipants, participantsToRemove) => {
+        if (participantsToRemove.length === 0) {
+            return;
+        }
+        const removed = new Set(participantsToRemove);
+        const nextParticipants = cachedParticipants.filter((participant) => !removed.has(participant));
+        if (nextParticipants.length === cachedParticipants.length) {
+            return;
+        }
+        if (nextParticipants.length === 0) {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const replaceParticipantUsersInCache = async (groupJid, cachedParticipants, participantsToReplace, replacementParticipants) => {
+        const toReplace = new Set(participantsToReplace);
+        const nextParticipants = cachedParticipants.filter((participant) => !toReplace.has(participant));
+        const existing = new Set(nextParticipants);
+        for (const participant of replacementParticipants) {
+            if (existing.has(participant)) {
+                continue;
+            }
+            existing.add(participant);
+            nextParticipants.push(participant);
+        }
+        if (areParticipantListsEqual(cachedParticipants, nextParticipants)) {
+            return;
+        }
+        if (nextParticipants.length === 0) {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const resolveGroupJidForParticipantCacheEvent = (event) => {
+        if (event.action === 'linked_group_promote' || event.action === 'linked_group_demote') {
+            return event.contextGroupJid ?? event.groupJid ?? null;
+        }
+        return event.groupJid ?? null;
+    };
+    const extractParticipantUsersFromGroupEvent = (event) => {
+        const candidates = [];
+        for (const participant of event.participants ?? []) {
+            if (participant.jid) {
+                candidates.push(participant.jid);
+            }
+            if (participant.lidJid) {
+                candidates.push(participant.lidJid);
+            }
+            if (participant.phoneJid) {
+                candidates.push(participant.phoneJid);
+            }
+        }
+        return sanitizeParticipantUsers(candidates);
+    };
+    const refreshParticipantUsers = (groupJid) => dedup.run(`refresh:${groupJid}`, async () => {
+        const queried = await queryGroupParticipantJids(groupJid);
+        const participants = sanitizeParticipantUsers(queried);
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants,
+            updatedAtMs: Date.now()
+        });
+        return participants;
+    });
+    const resolveParticipantUsers = (groupJid) => dedup.run(`resolve:${groupJid}`, async () => {
+        const cached = await participantsStore.getGroupParticipants(groupJid);
+        if (cached && cached.participants.length > 0) {
+            return sanitizeParticipantUsers(cached.participants);
+        }
+        return refreshParticipantUsers(groupJid);
+    });
+    const mutateFromGroupEvent = async (event) => {
+        const groupJid = resolveGroupJidForParticipantCacheEvent(event);
+        if (!groupJid) {
+            return;
+        }
+        if (event.action === 'delete') {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        const participantUsers = extractParticipantUsersFromGroupEvent(event);
+        if (event.action === 'create') {
+            if (participantUsers.length === 0) {
+                return;
+            }
+            await participantsStore.upsertGroupParticipants({
+                groupJid,
+                participants: participantUsers,
+                updatedAtMs: Date.now()
+            });
+            return;
+        }
+        const cached = await participantsStore.getGroupParticipants(groupJid);
+        if (!cached || cached.participants.length === 0) {
+            return;
+        }
+        const cachedParticipants = sanitizeParticipantUsers(cached.participants);
+        if (cachedParticipants.length === 0) {
+            return;
+        }
+        if (event.action === 'add' ||
+            event.action === 'promote' ||
+            event.action === 'demote' ||
+            event.action === 'linked_group_promote' ||
+            event.action === 'linked_group_demote') {
+            await mergeParticipantUsersIntoCache(groupJid, cachedParticipants, participantUsers);
+            return;
+        }
+        if (event.action === 'remove') {
+            await removeParticipantUsersFromCache(groupJid, cachedParticipants, participantUsers);
+            return;
+        }
+        if (event.action === 'modify') {
+            const authorUsers = event.authorJid ? sanitizeParticipantUsers([event.authorJid]) : [];
+            await replaceParticipantUsersInCache(groupJid, cachedParticipants, authorUsers, participantUsers);
+        }
+    };
+    return {
+        resolveParticipantUsers,
+        refreshParticipantUsers,
+        mutateFromGroupEvent
+    };
+}

package/dist/esm/client/persistence/WriteBehindPersistence.js

@@ -0,0 +1,125 @@
+import { BackgroundQueue } from '../../infra/perf/BackgroundQueue.js';
+import { toError } from '../../util/primitives.js';
+function mergeThread(previous, incoming) {
+    return {
+        jid: incoming.jid,
+        name: incoming.name ?? previous.name,
+        unreadCount: incoming.unreadCount ?? previous.unreadCount,
+        archived: incoming.archived ?? previous.archived,
+        pinned: incoming.pinned ?? previous.pinned,
+        muteEndMs: incoming.muteEndMs ?? previous.muteEndMs,
+        markedAsUnread: incoming.markedAsUnread ?? previous.markedAsUnread,
+        ephemeralExpiration: incoming.ephemeralExpiration ?? previous.ephemeralExpiration
+    };
+}
+function mergeContact(previous, incoming) {
+    return {
+        jid: incoming.jid,
+        displayName: incoming.displayName ?? previous.displayName,
+        pushName: incoming.pushName ?? previous.pushName,
+        lid: incoming.lid ?? previous.lid,
+        phoneNumber: incoming.phoneNumber ?? previous.phoneNumber,
+        lastUpdatedMs: Math.max(previous.lastUpdatedMs, incoming.lastUpdatedMs)
+    };
+}
+export class WriteBehindPersistence {
+    constructor(stores, logger, options = {}) {
+        this.logger = logger;
+        this.flushTimeoutMs = options.flushTimeoutMs ?? 5000;
+        const queueOptions = (domain) => ({
+            maxPendingKeys: options.maxPendingKeys ?? 4096,
+            maxWriteConcurrency: options.maxWriteConcurrency ?? 4,
+            flushTimeoutMs: this.flushTimeoutMs,
+            onError: (key, error, attempt) => {
+                this.logger.warn('write-behind error', {
+                    domain,
+                    key,
+                    attempt,
+                    message: toError(error).message
+                });
+            },
+            onPressure: (pendingKeys) => {
+                this.logger.warn('write-behind pressure', {
+                    domain,
+                    pendingKeys
+                });
+            },
+            onDiscard: (key) => {
+                this.logger.warn('write-behind discarded pending write', {
+                    domain,
+                    key
+                });
+            }
+        });
+        this.queues = {
+            messages: new BackgroundQueue((_key, value) => stores.messageStore.upsert(value), queueOptions('messages')),
+            threads: new BackgroundQueue((_key, value) => stores.threadStore.upsert(value), {
+                ...queueOptions('threads'),
+                coalesce: (previous, incoming) => mergeThread(previous, incoming)
+            }),
+            contacts: new BackgroundQueue((_key, value) => stores.contactStore.upsert(value), {
+                ...queueOptions('contacts'),
+                coalesce: (previous, incoming) => mergeContact(previous, incoming)
+            })
+        };
+    }
+    persistMessage(record) {
+        this.queues.messages.enqueue(`msg:${record.id}`, record);
+    }
+    persistMessageAsync(record) {
+        return this.queues.messages.enqueueAsync(`msg:${record.id}`, record);
+    }
+    persistThread(record) {
+        this.queues.threads.enqueue(`thread:${record.jid}`, record);
+    }
+    persistThreadAsync(record) {
+        return this.queues.threads.enqueueAsync(`thread:${record.jid}`, record);
+    }
+    persistContact(record) {
+        this.queues.contacts.enqueue(`contact:${record.jid}`, record);
+    }
+    persistContactAsync(record) {
+        return this.queues.contacts.enqueueAsync(`contact:${record.jid}`, record);
+    }
+    async flush(timeoutMs = this.flushTimeoutMs) {
+        const [messages, threads, contacts] = await Promise.all([
+            this.queues.messages.flush(timeoutMs),
+            this.queues.threads.flush(timeoutMs),
+            this.queues.contacts.flush(timeoutMs)
+        ]);
+        const result = this.toDrainResult(messages, threads, contacts);
+        if (result.remaining > 0) {
+            this.logger.warn('write-behind flush finished with pending writes', {
+                messagesRemaining: messages.remaining,
+                threadsRemaining: threads.remaining,
+                contactsRemaining: contacts.remaining
+            });
+        }
+        return result;
+    }
+    async destroy(timeoutMs = this.flushTimeoutMs) {
+        const [messages, threads, contacts] = await Promise.all([
+            this.queues.messages.destroy(timeoutMs),
+            this.queues.threads.destroy(timeoutMs),
+            this.queues.contacts.destroy(timeoutMs)
+        ]);
+        const result = this.toDrainResult(messages, threads, contacts);
+        if (result.remaining > 0) {
+            this.logger.warn('write-behind destroy finished with pending writes', {
+                messagesRemaining: messages.remaining,
+                threadsRemaining: threads.remaining,
+                contactsRemaining: contacts.remaining
+            });
+        }
+        return result;
+    }
+    toDrainResult(messages, threads, contacts) {
+        return {
+            messages,
+            threads,
+            contacts,
+            flushed: messages.flushed + threads.flushed + contacts.flushed,
+            remaining: messages.remaining + threads.remaining + contacts.remaining
+        };
+    }
+}

package/dist/esm/client/tokens/cs-token.js

@@ -0,0 +1,46 @@
+import { hmacSign, importHmacKey } from '../../crypto/core/index.js';
+import { TEXT_ENCODER } from '../../util/bytes.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+const CS_TOKEN_CACHE_MAX = 5;
+export class CsTokenGenerator {
+    constructor() {
+        this.cachedKey = null;
+        this.cachedSalt = null;
+        this.cache = new Map();
+    }
+    async generate(nctSalt, accountLid) {
+        const cached = this.cache.get(accountLid);
+        if (cached && this.isSameSalt(nctSalt)) {
+            return cached;
+        }
+        const key = await this.resolveKey(nctSalt);
+        const result = await hmacSign(key, TEXT_ENCODER.encode(accountLid));
+        setBoundedMapEntry(this.cache, accountLid, result, CS_TOKEN_CACHE_MAX);
+        return result;
+    }
+    invalidate() {
+        this.cachedKey = null;
+        this.cachedSalt = null;
+        this.cache.clear();
+    }
+    isSameSalt(salt) {
+        if (!this.cachedSalt || this.cachedSalt.length !== salt.length) {
+            return false;
+        }
+        for (let i = 0; i < salt.length; i += 1) {
+            if (this.cachedSalt[i] !== salt[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async resolveKey(salt) {
+        if (this.cachedKey && this.isSameSalt(salt)) {
+            return this.cachedKey;
+        }
+        this.cachedKey = await importHmacKey(salt);
+        this.cachedSalt = salt;
+        this.cache.clear();
+        return this.cachedKey;
+    }
+}