zapo-js 0.1.0

package/dist/esm/client/coordinators/WaPassiveTasksCoordinator.js

@@ -0,0 +1,196 @@
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { SIGNAL_SIGNED_PREKEY_ROTATION_INTERVAL_MS, SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS, SIGNAL_UPLOAD_PREKEYS_COUNT } from '../../signal/api/constants.js';
+import { buildPreKeyUploadIq, parsePreKeyUploadFailure } from '../../signal/api/prekeys.js';
+import { generatePreKeyPair } from '../../signal/registration/keygen.js';
+import { toError } from '../../util/primitives.js';
+export class WaPassiveTasksCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.signalStore = options.signalStore;
+        this.signalDigestSync = options.signalDigestSync;
+        this.signalRotateKey = options.signalRotateKey;
+        this.signedPreKeyRotationIntervalMs =
+            options.signedPreKeyRotationIntervalMs ?? SIGNAL_SIGNED_PREKEY_ROTATION_INTERVAL_MS;
+        this.signedPreKeyServerErrorBackoffMs =
+            options.signedPreKeyServerErrorBackoffMs ?? SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS;
+        this.runtime = options.runtime;
+        this.passiveTasksPromise = null;
+    }
+    startPassiveTasksAfterConnect() {
+        if (this.passiveTasksPromise) {
+            this.logger.trace('passive connect tasks already running');
+            return;
+        }
+        this.passiveTasksPromise = this.runPassiveTasksAfterConnect()
+            .catch((error) => {
+            this.logger.warn('passive connect tasks failed', {
+                message: toError(error).message
+            });
+        })
+            .finally(() => {
+            this.passiveTasksPromise = null;
+        });
+    }
+    resetInFlightState() {
+        if (!this.passiveTasksPromise) {
+            return;
+        }
+        this.logger.trace('passive connect tasks reset requested while run is still in-flight');
+    }
+    async runPassiveTasksAfterConnect() {
+        const credentials = this.runtime.getCurrentCredentials();
+        const isRegistered = credentials?.meJid !== null && credentials?.meJid !== undefined;
+        if (!isRegistered) {
+            this.logger.trace('passive connect tasks skipped: session is not registered');
+            return;
+        }
+        await this.uploadPreKeysIfMissing();
+        await this.validateDigestAndRecoverPreKeys();
+        await this.rotateSignedPreKeyIfDue();
+        await this.flushDanglingReceipts();
+    }
+    async validateDigestAndRecoverPreKeys() {
+        try {
+            const validation = await this.signalDigestSync.validateLocalKeyBundle();
+            if (validation.valid) {
+                this.logger.debug('signal digest validated', {
+                    preKeyCount: validation.preKeyCount
+                });
+                return;
+            }
+            this.logger.warn('signal digest validation failed', {
+                reason: validation.reason,
+                shouldReupload: validation.shouldReupload,
+                preKeyCount: validation.preKeyCount
+            });
+            if (!validation.shouldReupload) {
+                return;
+            }
+            await Promise.all([
+                this.signalStore.setServerHasPreKeys(false),
+                this.runtime.persistServerHasPreKeys(false)
+            ]);
+            await this.uploadPreKeysIfMissing();
+        }
+        catch (error) {
+            this.logger.warn('signal digest validation failed with exception', {
+                message: toError(error).message
+            });
+        }
+    }
+    async uploadPreKeysIfMissing() {
+        const serverHasPreKeys = await this.signalStore.getServerHasPreKeys();
+        if (serverHasPreKeys) {
+            this.logger.trace('prekey upload skipped: server already has prekeys');
+            return;
+        }
+        const [registrationInfo, signedPreKey] = await Promise.all([
+            this.signalStore.getRegistrationInfo(),
+            this.signalStore.getSignedPreKey()
+        ]);
+        if (!registrationInfo || !signedPreKey) {
+            this.logger.warn('prekey upload skipped: registration info is missing');
+            return;
+        }
+        const preKeys = await this.signalStore.getOrGenPreKeys(SIGNAL_UPLOAD_PREKEYS_COUNT, generatePreKeyPair);
+        if (preKeys.length === 0) {
+            throw new Error('no prekey available for upload');
+        }
+        const lastPreKeyId = preKeys[preKeys.length - 1].keyId;
+        const uploadNode = buildPreKeyUploadIq(registrationInfo, signedPreKey, preKeys);
+        const response = await this.runtime.queryWithContext('prekeys.upload', uploadNode, WA_DEFAULTS.IQ_TIMEOUT_MS, {
+            count: preKeys.length,
+            lastPreKeyId
+        });
+        if (response.attrs.type === 'result') {
+            await this.signalStore.markKeyAsUploaded(lastPreKeyId);
+            await Promise.all([
+                this.signalStore.setServerHasPreKeys(true),
+                this.runtime.persistServerHasPreKeys(true)
+            ]);
+            this.logger.info('uploaded prekeys to server', {
+                count: preKeys.length,
+                lastPreKeyId
+            });
+            return;
+        }
+        const failure = parsePreKeyUploadFailure(response);
+        this.logger.warn('upload prekeys failed', {
+            count: preKeys.length,
+            errorCode: failure.errorCode,
+            errorText: failure.errorText
+        });
+    }
+    async rotateSignedPreKeyIfDue() {
+        try {
+            const nowMs = Date.now();
+            const lastRotationTs = await this.signalStore.getSignedPreKeyRotationTs();
+            if (lastRotationTs === null) {
+                await this.signalStore.setSignedPreKeyRotationTs(nowMs);
+                this.logger.trace('signal rotate key skipped on first run');
+                return;
+            }
+            const elapsedMs = nowMs - lastRotationTs;
+            if (elapsedMs < this.signedPreKeyRotationIntervalMs) {
+                this.logger.trace('signal rotate key skipped: interval not reached', {
+                    remainingMs: this.signedPreKeyRotationIntervalMs - elapsedMs
+                });
+                return;
+            }
+            const result = await this.signalRotateKey.rotateSignedPreKey();
+            const nextRotationTs = this.resolveRotationTimestamp(nowMs, result.errorCode);
+            await this.signalStore.setSignedPreKeyRotationTs(nextRotationTs);
+            if (result.shouldDigestKey) {
+                await this.validateDigestAndRecoverPreKeys();
+            }
+        }
+        catch (error) {
+            this.logger.warn('signal rotate key failed', {
+                message: toError(error).message
+            });
+        }
+    }
+    resolveRotationTimestamp(nowMs, errorCode) {
+        if (errorCode !== undefined && errorCode >= 500) {
+            const retryInMs = Math.min(this.signedPreKeyServerErrorBackoffMs, this.signedPreKeyRotationIntervalMs);
+            this.logger.warn('signal rotate key scheduled with server error backoff', {
+                errorCode,
+                retryInMs
+            });
+            return nowMs - this.signedPreKeyRotationIntervalMs + retryInMs;
+        }
+        return nowMs;
+    }
+    async flushDanglingReceipts() {
+        const pending = this.runtime.takeDanglingReceipts();
+        if (pending.length === 0) {
+            return;
+        }
+        this.logger.info('flushing dangling receipts', { count: pending.length });
+        for (let index = 0; index < pending.length; index += 1) {
+            const node = pending[index];
+            try {
+                await this.runtime.sendNodeDirect(node);
+            }
+            catch (error) {
+                const normalized = toError(error);
+                if (this.runtime.shouldQueueDanglingReceipt(node, normalized)) {
+                    for (let restoreIndex = index; restoreIndex < pending.length; restoreIndex += 1) {
+                        this.runtime.requeueDanglingReceipt(pending[restoreIndex]);
+                    }
+                    this.logger.warn('stopped dangling receipt flush due transient send error', {
+                        remaining: pending.length - index,
+                        message: normalized.message
+                    });
+                    return;
+                }
+                this.logger.warn('dropping dangling receipt due non-retryable send error', {
+                    id: node.attrs.id,
+                    to: node.attrs.to,
+                    message: normalized.message
+                });
+            }
+        }
+        this.logger.info('dangling receipts flushed');
+    }
+}

package/dist/esm/client/coordinators/WaRetryCoordinator.js

@@ -0,0 +1,490 @@
+import { proto } from '../../proto.js';
+import { WA_MESSAGE_TAGS } from '../../protocol/constants.js';
+import { isGroupOrBroadcastJid, normalizeDeviceJid, parseSignalAddressFromJid, toUserJid } from '../../protocol/jid.js';
+import { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON } from '../../retry/constants.js';
+import { pickRetryStateMax } from '../../retry/outbound.js';
+import { parseRetryReceiptRequest } from '../../retry/parse.js';
+import { mapRetryReasonFromError } from '../../retry/reason.js';
+import { WaRetryReplayService } from '../../retry/replay.js';
+import { generatePreKeyPair } from '../../signal/registration/keygen.js';
+import { buildInboundRetryReceiptAckNode } from '../../transport/node/builders/message.js';
+import { buildRetryReceiptNode } from '../../transport/node/builders/retry.js';
+import { toError } from '../../util/primitives.js';
+function getRetryReasonName(code) {
+    if (code === undefined) {
+        return undefined;
+    }
+    const entry = Object.entries(RETRY_REASON).find(([, value]) => value === code);
+    return entry ? entry[0] : 'unknown';
+}
+function getRemoteRetryReasonLogFields(reason) {
+    return {
+        hasRemoteRetryReason: reason !== undefined,
+        remoteRetryReason: reason ?? null,
+        remoteRetryReasonName: getRetryReasonName(reason) ?? 'missing_in_retry_receipt'
+    };
+}
+export class WaRetryCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.retryStore = options.retryStore;
+        this.retryTtlMs = this.retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
+        this.signalStore = options.signalStore;
+        this.senderKeyStore = options.senderKeyStore;
+        this.signalProtocol = options.signalProtocol;
+        this.signalDeviceSync = options.signalDeviceSync;
+        this.signalMissingPreKeysSync = options.signalMissingPreKeysSync;
+        this.sendNode = options.sendNode;
+        this.getCurrentMeJid = options.getCurrentMeJid;
+        this.getCurrentMeLid = options.getCurrentMeLid;
+        this.getCurrentSignedIdentity = options.getCurrentSignedIdentity;
+        this.retryReplayService = new WaRetryReplayService({
+            logger: this.logger,
+            messageClient: options.messageClient,
+            signalProtocol: this.signalProtocol,
+            getCurrentMeJid: this.getCurrentMeJid,
+            getCurrentMeLid: this.getCurrentMeLid,
+            getCurrentSignedIdentity: this.getCurrentSignedIdentity
+        });
+        this.retryProcessingByMessageId = new Map();
+    }
+    async onDecryptFailure(context, error) {
+        try {
+            const prepared = await this.prepareDecryptFailureRetry(context, error);
+            if (!prepared) {
+                return false;
+            }
+            await this.sendDecryptFailureRetryReceipt(context, prepared);
+            return true;
+        }
+        catch (sendError) {
+            this.logger.warn('failed to send retry receipt for decrypt failure', {
+                id: context.stanzaId,
+                from: context.from,
+                participant: context.participant,
+                message: toError(sendError).message
+            });
+            return false;
+        }
+    }
+    async handleIncomingRetryReceipt(receiptNode) {
+        if (!this.isRetryReceiptNode(receiptNode)) {
+            return;
+        }
+        try {
+            await this.retryStore.cleanupExpired(Date.now());
+            const request = parseRetryReceiptRequest(receiptNode);
+            if (!request) {
+                return;
+            }
+            await this.handleParsedRetryRequest(receiptNode, request);
+        }
+        catch (error) {
+            this.logger.warn('failed handling incoming retry request', {
+                id: receiptNode.attrs.id,
+                from: receiptNode.attrs.from,
+                participant: receiptNode.attrs.participant,
+                message: toError(error).message
+            });
+        }
+        finally {
+            await this.sendRetryAckSafe(receiptNode);
+        }
+    }
+    isRetryReceiptNode(node) {
+        return (node.tag === WA_MESSAGE_TAGS.RECEIPT &&
+            (node.attrs.type === 'retry' || node.attrs.type === 'enc_rekey_retry'));
+    }
+    async prepareDecryptFailureRetry(context, error) {
+        const nowMs = Date.now();
+        const [, registrationInfo] = await Promise.all([
+            this.retryStore.cleanupExpired(nowMs),
+            this.signalStore.getRegistrationInfo()
+        ]);
+        if (!registrationInfo) {
+            this.logger.warn('retry receipt skipped: missing local registration info', {
+                id: context.stanzaId,
+                from: context.from
+            });
+            return null;
+        }
+        const requester = context.participant ?? context.from;
+        const expiresAtMs = nowMs + this.retryTtlMs;
+        const retryCount = await this.retryStore.incrementInboundCounter(context.stanzaId, requester, nowMs, expiresAtMs);
+        return {
+            registrationId: registrationInfo.registrationId,
+            retryCount,
+            retryKeys: retryCount >= RETRY_KEYS_MIN_COUNT
+                ? await this.buildRetryKeysSection(registrationInfo.identityKeyPair.pubKey)
+                : undefined,
+            retryReason: mapRetryReasonFromError(error),
+            timestamp: context.t ?? String(Math.trunc(nowMs / 1000))
+        };
+    }
+    async sendDecryptFailureRetryReceipt(context, prepared) {
+        const retryReceiptNode = buildRetryReceiptNode({
+            stanzaId: context.stanzaId,
+            to: context.from,
+            participant: context.participant,
+            recipient: context.recipient,
+            from: this.getCurrentMeJid() ?? undefined,
+            originalMsgId: context.stanzaId,
+            retryCount: prepared.retryCount,
+            t: prepared.timestamp,
+            registrationId: prepared.registrationId,
+            error: prepared.retryReason,
+            categoryPeer: context.messageNode.attrs.category === 'peer',
+            keys: prepared.retryKeys
+        });
+        await this.sendNode(retryReceiptNode);
+        this.logger.debug('sent retry receipt for decrypt failure', {
+            id: context.stanzaId,
+            to: context.from,
+            participant: context.participant,
+            retryCount: prepared.retryCount,
+            reason: prepared.retryReason,
+            withKeys: prepared.retryKeys !== undefined
+        });
+    }
+    async handleParsedRetryRequest(receiptNode, request) {
+        if (request.type === 'enc_rekey_retry') {
+            this.logger.info('received enc_rekey_retry request (voip path deferred)', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                from: request.from,
+                participant: request.participant,
+                remoteRetryCount: request.retryCount,
+                ...getRemoteRetryReasonLogFields(request.retryReason)
+            });
+            return;
+        }
+        await this.runRetryTaskSerialized(request.originalMsgId, async () => {
+            await this.processRetryRequest(request);
+        });
+    }
+    async processRetryRequest(request) {
+        const prepared = await this.prepareRetryResend(request);
+        if (!prepared) {
+            return;
+        }
+        const resendResult = await this.retryReplayService.resendOutboundMessage(prepared.outbound, prepared.requesterJid, request.retryCount);
+        if (resendResult === 'ineligible') {
+            this.logger.info('retry request marked ineligible for resend', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: prepared.requesterJid,
+                mode: prepared.outbound.replayMode
+            });
+            return;
+        }
+        this.logger.info('retry request processed and resent', {
+            id: request.stanzaId,
+            originalMsgId: request.originalMsgId,
+            requester: prepared.requesterJid,
+            mode: prepared.outbound.replayMode,
+            remoteRetryCount: request.retryCount,
+            ...getRemoteRetryReasonLogFields(request.retryReason)
+        });
+    }
+    async prepareRetryResend(request) {
+        const requesterJid = request.participant ?? request.from ?? null;
+        if (!requesterJid) {
+            this.logger.warn('retry request ignored: missing requester jid', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId
+            });
+            return null;
+        }
+        if (request.retryCount >= MAX_RETRY_ATTEMPTS) {
+            this.logger.info('retry request rejected: retry count exceeded', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                remoteRetryCount: request.retryCount,
+                ...getRemoteRetryReasonLogFields(request.retryReason)
+            });
+            return null;
+        }
+        const outbound = await this.retryStore.getOutboundMessage(request.originalMsgId);
+        if (!outbound) {
+            this.logger.info('retry request ignored: outbound message not found', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid
+            });
+            return null;
+        }
+        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid);
+        if (!sessionReady) {
+            this.logger.info('retry request rejected: missing compatible session', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                remoteRetryCount: request.retryCount,
+                ...getRemoteRetryReasonLogFields(request.retryReason)
+            });
+            return null;
+        }
+        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid);
+        if (!authorization.authorized) {
+            this.logger.info('retry request rejected', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                reason: authorization.reason,
+                remoteRetryCount: request.retryCount,
+                ...getRemoteRetryReasonLogFields(request.retryReason)
+            });
+            return null;
+        }
+        return {
+            requesterJid,
+            outbound
+        };
+    }
+    async trackOutboundReceipt(receiptNode) {
+        if (receiptNode.tag !== WA_MESSAGE_TAGS.RECEIPT) {
+            return;
+        }
+        const messageId = receiptNode.attrs.id;
+        if (!messageId) {
+            return;
+        }
+        const receiptType = receiptNode.attrs.type;
+        if (receiptType === 'retry' || receiptType === 'enc_rekey_retry') {
+            return;
+        }
+        const nextState = this.mapOutboundStateFromReceiptType(receiptType);
+        if (!nextState) {
+            return;
+        }
+        const current = await this.retryStore.getOutboundMessage(messageId);
+        if (!current) {
+            return;
+        }
+        const merged = pickRetryStateMax(current.state, nextState);
+        if (merged === current.state) {
+            return;
+        }
+        const nowMs = Date.now();
+        await this.retryStore.updateOutboundMessageState(messageId, merged, nowMs, nowMs + this.retryTtlMs);
+    }
+    async runRetryTaskSerialized(messageId, task) {
+        const previous = this.retryProcessingByMessageId.get(messageId) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(async () => task());
+        const tracker = current.then(() => undefined, () => undefined);
+        this.retryProcessingByMessageId.set(messageId, tracker);
+        try {
+            await current;
+        }
+        finally {
+            const latest = this.retryProcessingByMessageId.get(messageId);
+            if (latest === tracker) {
+                this.retryProcessingByMessageId.delete(messageId);
+            }
+        }
+    }
+    async buildRetryKeysSection(identity) {
+        const [signedPreKey, preKey] = await Promise.all([
+            this.signalStore.getSignedPreKey(),
+            this.signalStore.getOrGenSinglePreKey(generatePreKeyPair)
+        ]);
+        if (!signedPreKey) {
+            this.logger.warn('retry keys section skipped: signed prekey unavailable');
+            return undefined;
+        }
+        await this.signalStore.markKeyAsUploaded(preKey.keyId);
+        const signedIdentity = this.getCurrentSignedIdentity();
+        return {
+            identity,
+            key: {
+                id: preKey.keyId,
+                publicKey: preKey.keyPair.pubKey
+            },
+            skey: {
+                id: signedPreKey.keyId,
+                publicKey: signedPreKey.keyPair.pubKey,
+                signature: signedPreKey.signature
+            },
+            deviceIdentity: signedIdentity
+                ? proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish()
+                : undefined
+        };
+    }
+    async updateLocalSessionFromRetryRequest(request, requesterJid) {
+        await this.markRetryRequesterSenderKeyAsStale(request, requesterJid);
+        const address = parseSignalAddressFromJid(requesterJid);
+        const currentSession = await this.signalStore.getSession(address);
+        if (currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId) {
+            await this.signalStore.deleteSession(address);
+        }
+        if (request.keyBundle) {
+            if (!request.keyBundle.key) {
+                return false;
+            }
+            await this.signalProtocol.establishOutgoingSession(address, {
+                regId: request.regId,
+                identity: request.keyBundle.identity,
+                signedKey: {
+                    id: request.keyBundle.skey.id,
+                    publicKey: request.keyBundle.skey.publicKey,
+                    signature: request.keyBundle.skey.signature
+                },
+                oneTimeKey: {
+                    id: request.keyBundle.key.id,
+                    publicKey: request.keyBundle.key.publicKey
+                }
+            });
+            return true;
+        }
+        const hasSession = await this.signalProtocol.hasSession(address);
+        if (hasSession) {
+            return true;
+        }
+        const fetched = await this.fetchMissingPreKeysSession(requesterJid, request.regId);
+        if (!fetched) {
+            return false;
+        }
+        await this.signalProtocol.establishOutgoingSession(address, fetched);
+        return true;
+    }
+    async markRetryRequesterSenderKeyAsStale(request, requesterJid) {
+        if (!isGroupOrBroadcastJid(request.from)) {
+            return;
+        }
+        try {
+            const requesterAddress = parseSignalAddressFromJid(requesterJid);
+            const deleted = await this.senderKeyStore.markForgetSenderKey(request.from, [
+                requesterAddress
+            ]);
+            this.logger.debug('marked sender key as stale for group retry requester', {
+                groupJid: request.from,
+                requester: requesterJid,
+                deleted
+            });
+        }
+        catch (error) {
+            this.logger.warn('failed to mark sender key as stale for group retry requester', {
+                groupJid: request.from,
+                requester: requesterJid,
+                message: toError(error).message
+            });
+        }
+    }
+    async fetchMissingPreKeysSession(requesterJid, requesterRegistrationId) {
+        try {
+            const requesterAddress = parseSignalAddressFromJid(requesterJid);
+            const results = await this.signalMissingPreKeysSync.fetchMissingPreKeys([
+                {
+                    userJid: toUserJid(requesterJid),
+                    devices: [
+                        {
+                            deviceId: requesterAddress.device,
+                            registrationId: requesterRegistrationId
+                        }
+                    ]
+                }
+            ]);
+            const first = results[0];
+            if (!first || !('devices' in first)) {
+                this.logger.warn('missing prekeys fetch returned user error', {
+                    requester: requesterJid,
+                    errorText: first && 'errorText' in first ? first.errorText : 'unknown'
+                });
+                return null;
+            }
+            const requesterDeviceJid = normalizeDeviceJid(requesterJid);
+            const matched = first.devices.find((device) => normalizeDeviceJid(device.deviceJid) === requesterDeviceJid);
+            if (!matched) {
+                this.logger.warn('missing prekeys fetch did not return requested device', {
+                    requester: requesterJid,
+                    devices: first.devices.length
+                });
+                return null;
+            }
+            return matched.bundle;
+        }
+        catch (error) {
+            this.logger.warn('failed to fetch missing prekeys for retry requester', {
+                requester: requesterJid,
+                message: toError(error).message
+            });
+            return null;
+        }
+    }
+    async authorizeRetryRequest(request, outbound, requesterJid) {
+        if (outbound.state === 'ineligible') {
+            return { authorized: false, reason: `state_${outbound.state}` };
+        }
+        const isGroupOutbound = isGroupOrBroadcastJid(outbound.toJid);
+        if (!isGroupOutbound && (outbound.state === 'read' || outbound.state === 'played')) {
+            return { authorized: false, reason: `state_${outbound.state}` };
+        }
+        const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid);
+        if (!requesterAuthorized) {
+            return { authorized: false, reason: 'requester_device_not_authorized' };
+        }
+        return { authorized: true };
+    }
+    async isRequesterAuthorizedDevice(requesterJid) {
+        try {
+            const requesterUser = toUserJid(requesterJid);
+            const synced = await this.signalDeviceSync.syncDeviceList([requesterUser]);
+            const target = synced.find((entry) => entry.jid === requesterUser);
+            const authorized = new Set();
+            authorized.add(normalizeDeviceJid(requesterUser));
+            if (target) {
+                for (let index = 0; index < target.deviceJids.length; index += 1) {
+                    authorized.add(normalizeDeviceJid(target.deviceJids[index]));
+                }
+            }
+            return authorized.has(normalizeDeviceJid(requesterJid));
+        }
+        catch (error) {
+            this.logger.warn('retry authorization failed while syncing requester device list', {
+                requester: requesterJid,
+                message: toError(error).message
+            });
+            return false;
+        }
+    }
+    mapOutboundStateFromReceiptType(type) {
+        if (type === 'read') {
+            return 'read';
+        }
+        if (type === 'played') {
+            return 'played';
+        }
+        if (type === undefined ||
+            type === '' ||
+            type === 'delivery' ||
+            type === 'sender' ||
+            type === 'inactive' ||
+            type === 'peer_msg') {
+            return 'delivered';
+        }
+        return null;
+    }
+    async sendRetryAckSafe(receiptNode) {
+        if (!receiptNode.attrs.id || !receiptNode.attrs.from) {
+            this.logger.warn('retry ack skipped: missing receipt id/from', {
+                hasId: receiptNode.attrs.id !== undefined,
+                hasFrom: receiptNode.attrs.from !== undefined,
+                participant: receiptNode.attrs.participant,
+                type: receiptNode.attrs.type
+            });
+            return;
+        }
+        try {
+            await this.sendNode(buildInboundRetryReceiptAckNode(receiptNode));
+        }
+        catch (error) {
+            this.logger.warn('failed to send retry ack', {
+                id: receiptNode.attrs.id,
+                from: receiptNode.attrs.from,
+                participant: receiptNode.attrs.participant,
+                message: toError(error).message
+            });
+        }
+    }
+}