Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(engine): announce no edit for a wwebjs message decrypted later

Yudhi Armyndharis70cefb072e62
diff --git a/docs/29-engine-capability-matrix.md b/docs/29-engine-capability-matrix.md
index 7869ccb8a..d44d00722 100644
--- a/docs/29-engine-capability-matrix.md
+++ b/docs/29-engine-capability-matrix.md
@@ -840,7 +840,7 @@ OpenWA consumes events by normalizing them into `EngineEventCallbacks`; anything
| `message_reaction` | ✅ | | `contact_changed` | ❌ |
| `message_revoke_everyone` | ✅ | | `group_admin_changed` | ❌ |
| `message_revoke_me` | ❌ candidate | | `loading_screen` | ❌ |
-| `message_ciphertext` | ❌ | | `media_uploaded` | ❌ |
+| `message_ciphertext` | ✅ | | `media_uploaded` | ❌ |
| `message_ciphertext_failed` | ❌ | | `remote_session_saved` | ❌ |
| `call` | ✅ | | `unread_count` | ❌ candidate |
| `qr` | ✅ | | `vote_update` | ❌ candidate (poll-vote webhook) |
@@ -1051,7 +1051,7 @@ adapter sources — re-derive the same way when anything changes:
4 internal wiring, 1 class plumbing, **35 ❌ not exposed** (27 real capabilities + 8
session/transport settings that are not WhatsApp capabilities). The backlog is the ❌ rows minus
those 8 settings; 🔩 plumbing is correctly never exposed.
-- Events: Baileys **34** (18 consumed / 16 dropped), wwjs **31** (16 consumed / 15 dropped).
+- Events: Baileys **34** (18 consumed / 16 dropped), wwjs **31** (17 consumed / 14 dropped).
- **0** capabilities in 29.5.3: every capability with first-class symbols on both libraries is
either wired or classified with evidence. Some are Baileys-only despite typed whatsapp-web.js
symbols: `createGroup`, whose injected evaluate reaches a page internal without `findImpl`;
diff --git a/src/engine/adapters/wwebjs-message-changes.spec.ts b/src/engine/adapters/wwebjs-message-changes.spec.ts
index 9638e5664..d300397a3 100644
--- a/src/engine/adapters/wwebjs-message-changes.spec.ts
+++ b/src/engine/adapters/wwebjs-message-changes.spec.ts
@@ -118,6 +118,17 @@ const revokeEvent = (client: EventEmitter, id: string, opts: { fromMe?: boolean
const reactionEvent = (client: EventEmitter, id: string, reaction: string) =>
client.emit('message_reaction', { msgId: { _serialized: id }, id: { remote: CHAT }, reaction, senderId: CHAT });
+/** A `message_ciphertext`: a message WhatsApp Web could not decrypt yet, shown as "Waiting for this message". */
+const ciphertextEvent = (client: EventEmitter, id: string, subtype?: string) =>
+ client.emit('message_ciphertext', {
+ id: { _serialized: id },
+ from: CHAT,
+ to: SELF,
+ body: '',
+ type: 'ciphertext',
+ rawData: { type: 'ciphertext', ...(subtype ? { subtype } : {}) },
+ });
+
describe.each([
['PostgreSQL', 'postgres'],
['SQLite', 'better-sqlite3'],
@@ -512,6 +523,26 @@ describe.each([
expect(events('message.received')).toEqual([expect.objectContaining({ body: 'fixed', edited: true })]);
});
+ it.each([
+ ['before', true],
+ ['after', false],
+ ])('stores and announces a message decrypted in place unedited, its change raised %s it', async (_, changeFirst) => {
+ const contact = deferred<null>();
+ ciphertextEvent(client, 'A');
+ if (changeFirst) editEvent(client, 'A', 'hello');
+ client.emit('message', incoming('A', 'hello', { contact: contact.promise }));
+ if (!changeFirst) editEvent(client, 'A', 'hello');
+ await flush();
+ contact.resolve(null);
+ await flush();
+
+ expect(rows).toEqual([expect.objectContaining({ waMessageId: 'A', body: 'hello' })]);
+ expect(rows[0].metadata ?? {}).not.toHaveProperty('edited');
+ expect(events('message.received')).toEqual([expect.objectContaining({ body: 'hello' })]);
+ expect(events('message.received')[0]).not.toHaveProperty('edited');
+ expect(events('message.edited')).toEqual([]);
+ });
+
// Past the changes kept for one message they are delivered at once, before the message is handed over.
it('marks a message edited more times during its contact lookup than are kept for it', async () => {
const contact = deferred<null>();
@@ -972,4 +1003,63 @@ describe('changes kept while whatsapp-web.js processes a message (adapter level)
expect(order.indexOf('edit m0 kept')).toBeGreaterThan(order.indexOf('message m0'));
expect(order).toHaveLength(TRACKED + 3);
});
+
+ // WhatsApp Web decrypts such a message in place: whatsapp-web.js delivers it from the update that fills in its text,
+ // which raises message_edit too, before or after the message.
+ it.each([
+ ['before', true],
+ ['after', false],
+ ])('delivers no edit for the change that decrypts a message, %s the message', async (_, changeFirst) => {
+ const { client, order, bodies } = wire();
+ ciphertextEvent(client, 'A');
+ if (changeFirst) editEvent(client, 'A', 'hello');
+ client.emit('message', incoming('A', 'hello'));
+ if (!changeFirst) editEvent(client, 'A', 'hello');
+ await flush();
+
+ expect(order).toEqual(['message A']);
+ expect(bodies).toEqual(['hello']);
+ });
+
+ it.each([
+ ['after the change that decrypted it', true],
+ ['when its decryption raised no change', false],
+ ])('delivers the edits of a message decrypted in place %s, a restore included', async (_, decryptChange) => {
+ const { client, order } = wire();
+ ciphertextEvent(client, 'A');
+ client.emit('message', incoming('A', 'hello'));
+ if (decryptChange) editEvent(client, 'A', 'hello');
+ await flush();
+ editEvent(client, 'A', 'v1');
+ editEvent(client, 'A', 'hello');
+
+ expect(order).toEqual(['message A', 'edit A v1', 'edit A hello']);
+ });
+
+ it('delivers the edits of an own message decrypted in place when its decryption raised no change', async () => {
+ const { client, order } = wire();
+ ciphertextEvent(client, 'S');
+ client.emit('message_create', incoming('S', 'hello', { fromMe: true }));
+ await flush();
+ editEvent(client, 'S', 'v1', { fromMe: true });
+
+ expect(order).toEqual(['own S', 'edit S v1']);
+ });
+
+ it('delivers the edits of a message whatsapp-web.js does not deliver once decrypted', () => {
+ const { client, order } = wire();
+ ciphertextEvent(client, 'A', 'bot_unavailable_fanout');
+ editEvent(client, 'A', 'hello');
+
+ expect(order).toEqual(['edit A hello']);
+ });
+
+ it('remembers a bounded number of messages awaiting their decryption, forgetting the oldest first', () => {
+ const { client, order } = wire();
+ for (let i = 0; i <= TRACKED; i++) ciphertextEvent(client, `c${i}`);
+ editEvent(client, 'c0', 'forgotten');
+ editEvent(client, `c${TRACKED}`, 'decrypted');
+
+ expect(order).toEqual(['edit c0 forgotten']);
+ });
});
diff --git a/src/engine/adapters/wwebjs-message-events.ts b/src/engine/adapters/wwebjs-message-events.ts
index 333996d44..d3ea108f9 100644
--- a/src/engine/adapters/wwebjs-message-events.ts
+++ b/src/engine/adapters/wwebjs-message-events.ts
@@ -150,6 +150,32 @@ export function registerWwebjsMessageEvents(client: Client, host: WwebjsEngineHo
deliver();
};
+ // A message WhatsApp Web could not decrypt on arrival ("Waiting for this message") is decrypted in place later, and
+ // whatsapp-web.js delivers it from the update that fills in its text, which raises message_edit as well: no edit.
+ // Kept by id until that change is seen: unset until the message is delivered, then the text it was delivered with.
+ const decryptedLater = new Map<string, string | undefined>();
+
+ /** Whether a message_edit is the decryption of its message (see decryptedLater). Asked once per message. */
+ const isDecryption = (edit: EditedMessage): boolean => {
+ if (!decryptedLater.has(edit.messageId)) return false;
+ const delivered = decryptedLater.get(edit.messageId);
+ decryptedLater.delete(edit.messageId);
+ return delivered === undefined || delivered === edit.body;
+ };
+
+ const deliveredDecrypted = (message: IncomingMessage): void => {
+ if (decryptedLater.has(message.id)) decryptedLater.set(message.id, message.body);
+ };
+
+ client.on('message_ciphertext', msg => {
+ const id = readWid(msg.id);
+ // whatsapp-web.js delivers none of these once decrypted, so what changes them is left as it is.
+ const subtype = (msg.rawData as { subtype?: string } | undefined)?.subtype;
+ if (!id || subtype?.endsWith('_unavailable_fanout')) return;
+ decryptedLater.set(id, undefined);
+ if (decryptedLater.size > MAX_MESSAGES_IN_PROCESSING) decryptedLater.delete(decryptedLater.keys().next().value!);
+ });
+
client.on('message', msg => {
let base: IncomingMessage;
try {
@@ -158,6 +184,7 @@ export function registerWwebjsMessageEvents(client: Client, host: WwebjsEngineHo
host.logger.error('Error processing incoming message', String(error));
return;
}
+ deliveredDecrypted(base);
const ticket = admit(msg, base, true);
const processing = keepChanges(base, ticket);
const done = handleIncoming(host, msg, base, ticket, processing);
@@ -186,6 +213,7 @@ export function registerWwebjsMessageEvents(client: Client, host: WwebjsEngineHo
host.logger.error('Error processing outgoing message', String(error));
return;
}
+ deliveredDecrypted(incomingMessage);
// Synchronous, as the first await comes after it.
ticket = admit(msg, incomingMessage, !incomingMessage.isStatusBroadcast);
processing = keepChanges(incomingMessage, ticket);
@@ -337,6 +365,10 @@ export function registerWwebjsMessageEvents(client: Client, host: WwebjsEngineHo
mentionedIds: message.mentionedIds,
});
const payload: EditedMessage = buildEditedMessage(base, Boolean(message.hasMedia));
+ if (isDecryption(payload)) {
+ host.logger.debug('Ignoring the message_edit of a message decrypted in place', { msgId: payload.messageId });
+ return;
+ }
afterMessage(payload.messageId, () => host.getCallbacks().onMessageEdited?.(payload), {
editedText: payload.body,
});