zapo-js 0.1.1 → 0.2.0

package/dist/client/coordinators/WaRetryCoordinator.js

@@ -5,20 +5,26 @@ const _proto_1 = require("../../proto.js");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
 const constants_2 = require("../../retry/constants");
-const outbound_1 = require("../../retry/outbound");
 const parse_1 = require("../../retry/parse");
 const reason_1 = require("../../retry/reason");
 const replay_1 = require("../../retry/replay");
 const keygen_1 = require("../../signal/registration/keygen");
-const message_1 = require("../../transport/node/builders/message");
+const global_1 = require("../../transport/node/builders/global");
 const retry_1 = require("../../transport/node/builders/retry");
+const bytes_1 = require("../../util/bytes");
+const collections_1 = require("../../util/collections");
 const primitives_1 = require("../../util/primitives");
+const RETRY_CLEANUP_INTERVAL_MS = 30000;
+const RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES = 8192;
 function getRetryReasonName(code) {
     if (code === undefined) {
         return undefined;
     }
-    const entry = Object.entries(constants_2.RETRY_REASON).find(([, value]) => value === code);
-    return entry ? entry[0] : 'unknown';
+    for (const reasonName in constants_2.RETRY_REASON) {
+        if (constants_2.RETRY_REASON[reasonName] === code)
+            return reasonName;
+    }
+    return 'unknown';
 }
 function getRemoteRetryReasonLogFields(reason) {
     return {
@@ -29,6 +35,7 @@ function getRemoteRetryReasonLogFields(reason) {
 }
 class WaRetryCoordinator {
     constructor(options) {
+        this.nextRetryCleanupAtMs = 0;
         this.logger = options.logger;
         this.retryStore = options.retryStore;
         this.retryTtlMs = this.retryStore.getTtlMs?.() ?? constants_2.RETRY_OUTBOUND_TTL_MS;
@@ -50,6 +57,7 @@ class WaRetryCoordinator {
             getCurrentSignedIdentity: this.getCurrentSignedIdentity
         });
         this.retryProcessingByMessageId = new Map();
+        this.retrySessionBaseKeys = new Map();
     }
     async onDecryptFailure(context, error) {
         try {
@@ -74,12 +82,23 @@ class WaRetryCoordinator {
         if (!this.isRetryReceiptNode(receiptNode)) {
             return;
         }
+        let shouldAck = false;
         try {
-            await this.retryStore.cleanupExpired(Date.now());
-            const request = (0, parse_1.parseRetryReceiptRequest)(receiptNode);
+            await this.maybeCleanupRetryStore(Date.now());
+            const expectedToJids = [];
+            const meJid = this.getCurrentMeJid()?.trim();
+            const meLid = this.getCurrentMeLid()?.trim();
+            if (meJid) {
+                expectedToJids.push(meJid);
+            }
+            if (meLid) {
+                expectedToJids.push(meLid);
+            }
+            const request = (0, parse_1.parseRetryReceiptRequest)(receiptNode, expectedToJids.length > 0 ? { expectedToJids } : undefined);
             if (!request) {
                 return;
             }
+            shouldAck = true;
             await this.handleParsedRetryRequest(receiptNode, request);
         }
         catch (error) {
@@ -91,7 +110,9 @@ class WaRetryCoordinator {
             });
         }
         finally {
-            await this.sendRetryAckSafe(receiptNode);
+            if (shouldAck) {
+                await this.sendRetryAckSafe(receiptNode);
+            }
         }
     }
     isRetryReceiptNode(node) {
@@ -100,10 +121,7 @@ class WaRetryCoordinator {
     }
     async prepareDecryptFailureRetry(context, error) {
         const nowMs = Date.now();
-        const [, registrationInfo] = await Promise.all([
-            this.retryStore.cleanupExpired(nowMs),
-            this.signalStore.getRegistrationInfo()
-        ]);
+        const registrationInfo = await this.signalStore.getRegistrationInfo();
         if (!registrationInfo) {
             this.logger.warn('retry receipt skipped: missing local registration info', {
                 id: context.stanzaId,
@@ -130,7 +148,6 @@ class WaRetryCoordinator {
             to: context.from,
             participant: context.participant,
             recipient: context.recipient,
-            from: this.getCurrentMeJid() ?? undefined,
             originalMsgId: context.stanzaId,
             retryCount: prepared.retryCount,
             t: prepared.timestamp,
@@ -198,6 +215,22 @@ class WaRetryCoordinator {
             });
             return null;
         }
+        let requesterAddress;
+        let requesterNormalizedDeviceJid;
+        try {
+            const requesterParsed = (0, jid_1.parseJidFull)(requesterJid);
+            requesterAddress = requesterParsed.address;
+            requesterNormalizedDeviceJid = requesterParsed.normalizedJid;
+        }
+        catch (error) {
+            this.logger.info('retry request rejected: invalid requester jid', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return null;
+        }
         if (request.retryCount >= constants_2.MAX_RETRY_ATTEMPTS) {
             this.logger.info('retry request rejected: retry count exceeded', {
                 id: request.stanzaId,
@@ -217,7 +250,7 @@ class WaRetryCoordinator {
             });
             return null;
         }
-        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid);
+        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!sessionReady) {
             this.logger.info('retry request rejected: missing compatible session', {
                 id: request.stanzaId,
@@ -228,7 +261,7 @@ class WaRetryCoordinator {
             });
             return null;
         }
-        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid);
+        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!authorization.authorized) {
             this.logger.info('retry request rejected', {
                 id: request.stanzaId,
@@ -242,6 +275,8 @@ class WaRetryCoordinator {
         }
         return {
             requesterJid,
+            requesterAddress,
+            requesterNormalizedDeviceJid,
             outbound
         };
     }
@@ -261,20 +296,36 @@ class WaRetryCoordinator {
         if (!nextState) {
             return;
         }
-        const current = await this.retryStore.getOutboundMessage(messageId);
-        if (!current) {
-            return;
-        }
-        const merged = (0, outbound_1.pickRetryStateMax)(current.state, nextState);
-        if (merged === current.state) {
-            return;
-        }
-        const nowMs = Date.now();
-        await this.retryStore.updateOutboundMessageState(messageId, merged, nowMs, nowMs + this.retryTtlMs);
+        await this.runRetryTaskSerialized(messageId, async () => {
+            const current = await this.retryStore.getOutboundMessage(messageId);
+            if (!current) {
+                return;
+            }
+            const nowMs = Date.now();
+            const expiresAtMs = nowMs + this.retryTtlMs;
+            const merged = (0, parse_1.pickRetryStateMax)(current.state, nextState);
+            if (merged !== current.state) {
+                await this.retryStore.updateOutboundMessageState(messageId, merged, nowMs, expiresAtMs);
+            }
+            const requesterJid = receiptNode.attrs.participant ?? receiptNode.attrs.from;
+            if (!requesterJid) {
+                return;
+            }
+            try {
+                await this.retryStore.markOutboundRequesterDelivered(messageId, (0, jid_1.normalizeDeviceJid)(requesterJid), nowMs, expiresAtMs);
+            }
+            catch (error) {
+                this.logger.warn('failed to update outbound requester delivery state', {
+                    id: messageId,
+                    requester: requesterJid,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        });
     }
     async runRetryTaskSerialized(messageId, task) {
         const previous = this.retryProcessingByMessageId.get(messageId) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(async () => task());
+        const current = previous.then(task);
         const tracker = current.then(() => undefined, () => undefined);
         this.retryProcessingByMessageId.set(messageId, tracker);
         try {
@@ -314,18 +365,47 @@ class WaRetryCoordinator {
                 : undefined
         };
     }
-    async updateLocalSessionFromRetryRequest(request, requesterJid) {
-        await this.markRetryRequesterSenderKeyAsStale(request, requesterJid);
-        const address = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
-        const currentSession = await this.signalStore.getSession(address);
-        if (currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId) {
-            await this.signalStore.deleteSession(address);
+    async updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
+        const [, currentSession] = await Promise.all([
+            this.markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress),
+            this.signalStore.getSession(requesterAddress)
+        ]);
+        const regIdMismatch = !!currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId;
+        if (regIdMismatch && !request.keyBundle) {
+            await this.signalStore.deleteSession(requesterAddress);
         }
         if (request.keyBundle) {
-            if (!request.keyBundle.key) {
+            if (!request.keyBundle.key || !request.keyBundle.skey.signature) {
                 return false;
             }
-            await this.signalProtocol.establishOutgoingSession(address, {
+            if (request.offline) {
+                if (!currentSession) {
+                    this.logger.info('retry request rejected: offline retry missing existing session', {
+                        id: request.stanzaId,
+                        originalMsgId: request.originalMsgId,
+                        requester: requesterJid,
+                        remoteRetryCount: request.retryCount,
+                        ...getRemoteRetryReasonLogFields(request.retryReason)
+                    });
+                    await this.signalStore.deleteSession(requesterAddress);
+                    return false;
+                }
+                if (regIdMismatch) {
+                    this.logger.info('retry request rejected: offline retry registration id mismatch', {
+                        id: request.stanzaId,
+                        originalMsgId: request.originalMsgId,
+                        requester: requesterJid,
+                        remoteRetryCount: request.retryCount,
+                        ...getRemoteRetryReasonLogFields(request.retryReason)
+                    });
+                    await this.signalStore.deleteSession(requesterAddress);
+                    return false;
+                }
+            }
+            else if (regIdMismatch) {
+                await this.signalStore.deleteSession(requesterAddress);
+            }
+            await this.signalProtocol.establishOutgoingSession(requesterAddress, {
                 regId: request.regId,
                 identity: request.keyBundle.identity,
                 signedKey: {
@@ -338,25 +418,57 @@ class WaRetryCoordinator {
                     publicKey: request.keyBundle.key.publicKey
                 }
             });
+            return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+        }
+        const sessionStillExists = currentSession !== null && !regIdMismatch;
+        if (sessionStillExists) {
+            return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+        }
+        const fetched = await this.fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, request.regId);
+        if (!fetched) {
+            return false;
+        }
+        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
+        return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+    }
+    async applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
+        if (request.retryCount < 2) {
+            return true;
+        }
+        const currentSession = await this.signalStore.getSession(requesterAddress);
+        const sessionBaseKey = currentSession?.aliceBaseKey ?? null;
+        if (!sessionBaseKey) {
             return true;
         }
-        const hasSession = await this.signalProtocol.hasSession(address);
-        if (hasSession) {
+        const expiresAtMs = Date.now() + this.retryTtlMs;
+        if (request.retryCount === 2) {
+            this.setRetrySessionBaseKey(request.originalMsgId, requesterNormalizedDeviceJid, sessionBaseKey, expiresAtMs);
             return true;
         }
-        const fetched = await this.fetchMissingPreKeysSession(requesterJid, request.regId);
+        const saved = this.getRetrySessionBaseKey(request.originalMsgId, requesterNormalizedDeviceJid);
+        if (!saved || !(0, bytes_1.uint8Equal)(saved.baseKey, sessionBaseKey)) {
+            return true;
+        }
+        await this.signalStore.deleteSession(requesterAddress);
+        this.logger.info('retry request forcing session refresh due to repeated base key', {
+            id: request.stanzaId,
+            originalMsgId: request.originalMsgId,
+            requester: requesterJid,
+            remoteRetryCount: request.retryCount,
+            ...getRemoteRetryReasonLogFields(request.retryReason)
+        });
+        const fetched = await this.fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, request.regId);
         if (!fetched) {
             return false;
         }
-        await this.signalProtocol.establishOutgoingSession(address, fetched);
+        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
         return true;
     }
-    async markRetryRequesterSenderKeyAsStale(request, requesterJid) {
+    async markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress) {
         if (!(0, jid_1.isGroupOrBroadcastJid)(request.from)) {
             return;
         }
         try {
-            const requesterAddress = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
             const deleted = await this.senderKeyStore.markForgetSenderKey(request.from, [
                 requesterAddress
             ]);
@@ -374,12 +486,11 @@ class WaRetryCoordinator {
             });
         }
     }
-    async fetchMissingPreKeysSession(requesterJid, requesterRegistrationId) {
+    async fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, requesterRegistrationId) {
         try {
-            const requesterAddress = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
             const results = await this.signalMissingPreKeysSync.fetchMissingPreKeys([
                 {
-                    userJid: (0, jid_1.toUserJid)(requesterJid),
+                    userJid: `${requesterAddress.user}@${requesterAddress.server}`,
                     devices: [
                         {
                             deviceId: requesterAddress.device,
@@ -396,8 +507,7 @@ class WaRetryCoordinator {
                 });
                 return null;
             }
-            const requesterDeviceJid = (0, jid_1.normalizeDeviceJid)(requesterJid);
-            const matched = first.devices.find((device) => (0, jid_1.normalizeDeviceJid)(device.deviceJid) === requesterDeviceJid);
+            const matched = first.devices.find((device) => (0, jid_1.normalizeDeviceJid)(device.deviceJid) === requesterNormalizedDeviceJid);
             if (!matched) {
                 this.logger.warn('missing prekeys fetch did not return requested device', {
                     requester: requesterJid,
@@ -415,33 +525,59 @@ class WaRetryCoordinator {
             return null;
         }
     }
-    async authorizeRetryRequest(request, outbound, requesterJid) {
+    async authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         if (outbound.state === 'ineligible') {
             return { authorized: false, reason: `state_${outbound.state}` };
         }
+        let requesterStatus = null;
+        try {
+            requesterStatus = await this.retryStore.getOutboundRequesterStatus(outbound.messageId, requesterNormalizedDeviceJid);
+        }
+        catch (error) {
+            this.logger.warn('failed to resolve outbound requester status from retry store', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+        if (requesterStatus) {
+            if (!requesterStatus.eligible) {
+                return { authorized: false, reason: 'requester_device_not_eligible' };
+            }
+            if (requesterStatus.delivered) {
+                return { authorized: false, reason: 'requester_already_delivered' };
+            }
+        }
         const isGroupOutbound = (0, jid_1.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' };
+        if (!requesterStatus) {
+            const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+            if (!requesterAuthorized) {
+                return { authorized: false, reason: 'requester_device_not_authorized' };
+            }
         }
         return { authorized: true };
     }
-    async isRequesterAuthorizedDevice(requesterJid) {
+    async isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         try {
-            const requesterUser = (0, jid_1.toUserJid)(requesterJid);
+            const requesterUser = `${requesterAddress.user}@${requesterAddress.server}`;
+            if (requesterNormalizedDeviceJid === (0, jid_1.normalizeDeviceJid)(requesterUser)) {
+                return true;
+            }
             const synced = await this.signalDeviceSync.syncDeviceList([requesterUser]);
             const target = synced.find((entry) => entry.jid === requesterUser);
-            const authorized = new Set();
-            authorized.add((0, jid_1.normalizeDeviceJid)(requesterUser));
-            if (target) {
-                for (let index = 0; index < target.deviceJids.length; index += 1) {
-                    authorized.add((0, jid_1.normalizeDeviceJid)(target.deviceJids[index]));
+            if (!target) {
+                return false;
+            }
+            for (let index = 0; index < target.deviceJids.length; index += 1) {
+                if ((0, jid_1.normalizeDeviceJid)(target.deviceJids[index]) === requesterNormalizedDeviceJid) {
+                    return true;
                 }
             }
-            return authorized.has((0, jid_1.normalizeDeviceJid)(requesterJid));
+            return false;
         }
         catch (error) {
             this.logger.warn('retry authorization failed while syncing requester device list', {
@@ -479,7 +615,11 @@ class WaRetryCoordinator {
             return;
         }
         try {
-            await this.sendNode((0, message_1.buildInboundRetryReceiptAckNode)(receiptNode));
+            await this.sendNode((0, global_1.buildAckNode)({
+                kind: 'receipt',
+                node: receiptNode,
+                retryType: true
+            }));
         }
         catch (error) {
             this.logger.warn('failed to send retry ack', {
@@ -490,5 +630,50 @@ class WaRetryCoordinator {
             });
         }
     }
+    async maybeCleanupRetryStore(nowMs) {
+        if (nowMs < this.nextRetryCleanupAtMs) {
+            return;
+        }
+        this.nextRetryCleanupAtMs = nowMs + RETRY_CLEANUP_INTERVAL_MS;
+        this.cleanupRetrySessionBaseKeys(nowMs);
+        try {
+            await this.retryStore.cleanupExpired(nowMs);
+        }
+        catch (error) {
+            this.logger.warn('retry store cleanup failed', {
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+    }
+    retrySessionBaseKeyMapKey(originalMsgId, requesterNormalizedDeviceJid) {
+        return `${originalMsgId}|${requesterNormalizedDeviceJid}`;
+    }
+    setRetrySessionBaseKey(originalMsgId, requesterNormalizedDeviceJid, baseKey, expiresAtMs) {
+        const key = this.retrySessionBaseKeyMapKey(originalMsgId, requesterNormalizedDeviceJid);
+        (0, collections_1.setBoundedMapEntry)(this.retrySessionBaseKeys, key, {
+            baseKey: Uint8Array.from(baseKey),
+            expiresAtMs
+        }, RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES);
+    }
+    getRetrySessionBaseKey(originalMsgId, requesterNormalizedDeviceJid) {
+        const key = this.retrySessionBaseKeyMapKey(originalMsgId, requesterNormalizedDeviceJid);
+        const entry = this.retrySessionBaseKeys.get(key);
+        if (!entry) {
+            return null;
+        }
+        if (entry.expiresAtMs <= Date.now()) {
+            this.retrySessionBaseKeys.delete(key);
+            return null;
+        }
+        return entry;
+    }
+    cleanupRetrySessionBaseKeys(nowMs) {
+        for (const [key, entry] of this.retrySessionBaseKeys) {
+            if (entry.expiresAtMs > nowMs) {
+                continue;
+            }
+            this.retrySessionBaseKeys.delete(key);
+        }
+    }
 }
 exports.WaRetryCoordinator = WaRetryCoordinator;

package/dist/client/coordinators/WaStreamControlCoordinator.js

@@ -19,7 +19,7 @@ function createStreamControlHandler(options) {
     const restartBackendAfterStreamControl = async (reason) => {
         logger.info('restarting backend after stream control', { reason });
         try {
-            await connect();
+            await connect(constants_1.WA_CONNECTION_REASONS.RECONNECTED);
         }
         catch (error) {
             logger.warn('failed to restart backend after stream control', {
@@ -46,29 +46,36 @@ function createStreamControlHandler(options) {
             });
         }
     };
+    const stopCommsImmediately = () => {
+        void getComms()?.stopComms();
+    };
     const forceLoginDueToStreamError = async (code) => {
-        await runStreamControlLifecycle(`stream_error_code_${code}`, async () => {
+        const reason = constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_FORCE_LOGIN;
+        stopCommsImmediately();
+        await runStreamControlLifecycle(reason, async () => {
             logger.warn('received forced login stream error; starting login lifecycle', {
                 code
             });
-            await disconnect();
+            await disconnect(reason, true, code);
             await clearStoredCredentials();
-            await restartBackendAfterStreamControl(`stream_error_code_${code}`);
+            await restartBackendAfterStreamControl(reason);
         });
     };
-    const disconnectDueToStreamError = async (reason) => {
+    const disconnectDueToStreamError = async (reason, code) => {
+        stopCommsImmediately();
         await runStreamControlLifecycle(reason, async () => {
             logger.warn('disconnecting due to stream control node', { reason });
-            await disconnect();
+            await disconnect(reason, false, code);
         });
     };
-    const logoutDueToStreamError = async (reason, shouldRestartBackend) => {
+    const logoutDueToStreamError = async (reason, code, shouldRestartBackend) => {
+        stopCommsImmediately();
         await runStreamControlLifecycle(reason, async () => {
             logger.warn('logging out due to stream control node', {
                 reason,
                 shouldRestartBackend
             });
-            await disconnect();
+            await disconnect(reason, true, code);
             await clearStoredCredentials();
             if (shouldRestartBackend) {
                 await restartBackendAfterStreamControl(reason);
@@ -89,7 +96,7 @@ function createStreamControlHandler(options) {
                             return;
                         }
                         if (result.code === constants_1.WA_STREAM_SIGNALING.FORCE_LOGOUT_CODE) {
-                            await logoutDueToStreamError(`stream_error_code_${constants_1.WA_STREAM_SIGNALING.FORCE_LOGOUT_CODE}`, true);
+                            await logoutDueToStreamError(constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_FORCE_LOGOUT, result.code, true);
                             return;
                         }
                     }
@@ -97,11 +104,11 @@ function createStreamControlHandler(options) {
                     return;
                 case 'stream_error_replaced':
                     logger.warn('received stream:error replaced, stopping client');
-                    await disconnectDueToStreamError(constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED);
+                    await disconnectDueToStreamError(constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED, null);
                     return;
                 case 'stream_error_device_removed':
                     logger.warn('received stream:error device removed, logging out');
-                    await logoutDueToStreamError(constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED, false);
+                    await logoutDueToStreamError(constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED, null, false);
                     return;
                 case 'stream_error_ack':
                     logger.warn('received stream:error ack', { id: result.id });