zapo-js 0.3.0 → 1.0.0

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

@@ -1,5 +1,7 @@
-import { createIncomingBaseEvent, createIncomingFailureHandler, createIncomingGroupNotificationHandler, createIncomingNotificationHandler, createIncomingReceiptHandler, createIncomingRegistrationNotificationHandler, createInfoBulletinNotificationEvent, createUnhandledIncomingNodeEvent } from '../incoming.js';
-import { WA_IQ_TYPES, WA_MESSAGE_TAGS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES, WA_SIGNALING } from '../../protocol/constants.js';
+import { parseChatstateNode } from '../events/chatstate.js';
+import { buildInboundAck, createIncomingBaseEvent, createIncomingBusinessNotificationHandler, createIncomingCallHandler, createIncomingFailureHandler, createIncomingGroupNotificationHandler, createIncomingNotificationHandler, createIncomingPictureNotificationHandler, createIncomingReceiptHandler, createIncomingRegistrationNotificationHandler, createInfoBulletinNotificationEvent, createUnhandledIncomingNodeEvent, sendSafeAck } from '../events/incoming.js';
+import { parsePresenceNode } from '../events/presence.js';
+import { WA_IQ_TYPES, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_NODE_TAGS, WA_NOTIFICATION_TYPES, WA_SIGNALING } from '../../protocol/constants.js';
 import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
 import { parseStreamControlNode, parseSuccessPersistAttributes } from '../../transport/stream/parse.js';
 import { parseOptionalInt, toError } from '../../util/primitives.js';
@@ -11,12 +13,14 @@ const INFO_BULLETIN_CHILD_TAGS = new Set([
     'thread_metadata',
     'client_expiration'
 ]);
+const FILTER_PROTECTED_TAGS = new Set([WA_NODE_TAGS.SUCCESS, 'failure']);
 export class WaIncomingNodeCoordinator {
     constructor(options) {
         this.logger = options.logger;
         this.runtime = options.runtime;
         this.offlineResume = options.offlineResume;
         this.nodeHandlerRegistry = new Map();
+        this.stanzaFilters = [];
         this.registerDefaultIncomingHandlers();
         this.mediaConnWarmupPromise = null;
     }
@@ -34,6 +38,9 @@ export class WaIncomingNodeCoordinator {
             await this.runtime.handleStreamControlResult(streamControlResult);
             return;
         }
+        if (await this.applyStanzaFilters(node)) {
+            return;
+        }
         if (await this.handleSuccessNode(node)) {
             return;
         }
@@ -46,6 +53,46 @@ export class WaIncomingNodeCoordinator {
         }
         this.runtime.emitUnhandledIncomingNode(createUnhandledIncomingNodeEvent(node));
     }
+    registerIncomingStanzaFilter(filter) {
+        this.stanzaFilters.push(filter);
+        return () => {
+            const index = this.stanzaFilters.indexOf(filter);
+            if (index !== -1) {
+                this.stanzaFilters.splice(index, 1);
+            }
+        };
+    }
+    async applyStanzaFilters(node) {
+        if (this.stanzaFilters.length === 0 || FILTER_PROTECTED_TAGS.has(node.tag)) {
+            return false;
+        }
+        const filterLogger = this.logger.child({ tag: node.tag, id: node.attrs.id });
+        for (let i = 0; i < this.stanzaFilters.length; i += 1) {
+            let verdict;
+            try {
+                verdict = await this.stanzaFilters[i](node);
+            }
+            catch (error) {
+                filterLogger.warn('incoming stanza filter threw', {
+                    message: toError(error).message
+                });
+                continue;
+            }
+            if (!verdict) {
+                continue;
+            }
+            filterLogger.trace('incoming stanza dropped by filter', {
+                type: node.attrs.type,
+                from: node.attrs.from
+            });
+            const ack = buildInboundAck(node);
+            if (ack) {
+                await sendSafeAck(this.logger, this.runtime.sendNode, ack);
+            }
+            return true;
+        }
+        return false;
+    }
     registerIncomingHandler(registration) {
         const handlersByTag = this.nodeHandlerRegistry.get(registration.tag);
         const entry = {
@@ -120,7 +167,8 @@ export class WaIncomingNodeCoordinator {
         return false;
     }
     isRetryReceiptType(type) {
-        return type === 'retry' || type === 'enc_rekey_retry';
+        return (type === WA_MESSAGE_TYPES.RECEIPT_TYPE_RETRY ||
+            type === WA_MESSAGE_TYPES.RECEIPT_TYPE_ENC_REKEY_RETRY);
     }
     registerDefaultIncomingHandlers() {
         const runtime = this.runtime;
@@ -148,6 +196,26 @@ export class WaIncomingNodeCoordinator {
                 emitUnhandledStanza: runtime.emitUnhandledIncomingNode
             })
         });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.NOTIFICATION,
+            subtype: WA_NOTIFICATION_TYPES.BUSINESS,
+            handler: createIncomingBusinessNotificationHandler({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitBusinessEvent: runtime.emitBusinessEvent,
+                emitUnhandledStanza: runtime.emitUnhandledIncomingNode
+            })
+        });
+        this.registerIncomingHandler({
+            tag: WA_NODE_TAGS.NOTIFICATION,
+            subtype: WA_NOTIFICATION_TYPES.PICTURE,
+            handler: createIncomingPictureNotificationHandler({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitPictureEvent: runtime.emitPictureEvent,
+                emitUnhandledStanza: runtime.emitUnhandledIncomingNode
+            })
+        });
         this.registerIncomingHandler({
             tag: WA_NODE_TAGS.NOTIFICATION,
             subtype: WA_NOTIFICATION_TYPES.REGISTRATION,
@@ -164,6 +232,7 @@ export class WaIncomingNodeCoordinator {
                 logger: this.logger,
                 sendNode: runtime.sendNode,
                 emitIncomingNotification: runtime.emitIncomingNotification,
+                emitMexNotification: runtime.emitMexNotification,
                 emitUnhandledStanza: runtime.emitUnhandledIncomingNode,
                 syncAppState: runtime.syncAppState
             })
@@ -183,28 +252,39 @@ export class WaIncomingNodeCoordinator {
             })
         });
         this.registerIncomingHandler({
-            tag: 'presence',
+            tag: WA_NODE_TAGS.PRESENCE,
+            // eslint-disable-next-line @typescript-eslint/require-await
             handler: async (node) => {
-                runtime.emitIncomingPresence(createIncomingBaseEvent(node));
+                runtime.emitIncomingPresence({
+                    ...createIncomingBaseEvent(node),
+                    ...parsePresenceNode(node)
+                });
                 return true;
             }
         });
         this.registerIncomingHandler({
-            tag: 'chatstate',
+            tag: WA_NODE_TAGS.CHATSTATE,
+            // eslint-disable-next-line @typescript-eslint/require-await
             handler: async (node) => {
+                const parsed = parseChatstateNode(node);
+                if (!parsed) {
+                    return false;
+                }
                 runtime.emitIncomingChatstate({
                     ...createIncomingBaseEvent(node),
-                    participantJid: node.attrs.participant
+                    ...parsed
                 });
                 return true;
             }
         });
         this.registerIncomingHandler({
-            tag: 'call',
-            handler: async (node) => {
-                runtime.emitIncomingCall(createIncomingBaseEvent(node));
-                return true;
-            }
+            tag: WA_NODE_TAGS.CALL,
+            handler: createIncomingCallHandler({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitIncomingCall: runtime.emitIncomingCall,
+                getCurrentCredentials: runtime.getCurrentCredentials
+            })
         });
         this.registerIncomingHandler({
             tag: 'failure',
@@ -218,8 +298,13 @@ export class WaIncomingNodeCoordinator {
         });
         this.registerIncomingHandler({
             tag: WA_NODE_TAGS.ERROR,
+            // eslint-disable-next-line @typescript-eslint/require-await
             handler: async (node) => {
-                runtime.emitIncomingErrorStanza(createIncomingBaseEvent(node));
+                runtime.emitIncomingErrorStanza({
+                    ...createIncomingBaseEvent(node),
+                    code: parseOptionalInt(node.attrs.code),
+                    text: node.attrs.text
+                });
                 return true;
             }
         });

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

@@ -0,0 +1,38 @@
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { toError } from '../../util/primitives.js';
+/** Builds a {@link WaLowLevelCoordinator} from its transport dependencies. */
+export function createLowLevelCoordinator(options) {
+    const { logger, nodeOrchestrator, incomingNode, receiptQueue, isConnected } = options;
+    const defaultIqTimeoutMs = options.defaultIqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS;
+    return {
+        sendNode: async (node) => {
+            try {
+                await nodeOrchestrator.sendNode(node);
+            }
+            catch (error) {
+                const normalized = toError(error);
+                if (receiptQueue.shouldQueue(node, normalized)) {
+                    receiptQueue.enqueue(node);
+                    logger.warn('queued dangling receipt after send failure', {
+                        id: node.attrs.id,
+                        to: node.attrs.to,
+                        message: normalized.message,
+                        queueSize: receiptQueue.size()
+                    });
+                    return;
+                }
+                throw normalized;
+            }
+        },
+        query: async (node, timeoutMs = defaultIqTimeoutMs, queryOptions = {}) => {
+            if (!isConnected()) {
+                throw new Error('client is not connected');
+            }
+            logger.debug('wa client query', { tag: node.tag, id: node.attrs.id, timeoutMs });
+            return nodeOrchestrator.query(node, timeoutMs, queryOptions);
+        },
+        registerIncomingHandler: (registration) => incomingNode.registerIncomingHandler(registration),
+        unregisterIncomingHandler: (registration) => incomingNode.unregisterIncomingHandler(registration),
+        registerIncomingStanzaFilter: (filter) => incomingNode.registerIncomingStanzaFilter(filter)
+    };
+}

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

@@ -0,0 +1,361 @@
+import { createWriteStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
+import { aggregateReceiptTargets } from '../events/receipt.js';
+import { buildAddonAdditionalData, decodeAddonPlaintext, decryptAddonPayload, identifyEncryptedAddon, resolveParentMessageSecret, resolvePollOptionNames, shouldUseAddonAdditionalData } from '../../message/crypto/addon-crypto.js';
+import { unwrapMessage } from '../../message/encode/content.js';
+import { resolveMediaPayload } from '../../message/encode/media-payload.js';
+import { proto } from '../../proto.js';
+import { applyDeviceToJid, normalizeRecipientJid } from '../../protocol/jid.js';
+import { runMexQuery } from '../../transport/node/mex/client.js';
+import { readAllBytes } from '../../util/bytes.js';
+import { tryAsNumber, tryAsString } from '../../util/coercion.js';
+import { toError } from '../../util/primitives.js';
+function parseReachoutTimelockMexResponse(data) {
+    const root = data?.xwa2_fetch_account_reachout_timelock;
+    return {
+        isActive: root?.is_active === true,
+        enforcementType: tryAsString(root?.enforcement_type),
+        enforcementEndsAt: tryAsNumber(root?.time_enforcement_ends)
+    };
+}
+function parseMessageCappingMexResponse(data) {
+    const root = data?.xwa2_message_capping_info;
+    return {
+        totalQuota: tryAsNumber(root?.total_quota),
+        usedQuota: tryAsNumber(root?.used_quota),
+        cycleStartAt: tryAsNumber(root?.cycle_start_timestamp),
+        cycleEndAt: tryAsNumber(root?.cycle_end_timestamp),
+        serverSentAt: tryAsNumber(root?.server_sent_timestamp),
+        oteStatus: tryAsString(root?.ote_status),
+        mvStatus: tryAsString(root?.mv_status),
+        cappingStatus: tryAsString(root?.capping_status)
+    };
+}
+/**
+ * Coordinates outbound message sending, receipts, addon decryption, media
+ * download, and the related MEX account queries. Accessed via
+ * {@link WaClient.message}.
+ */
+export class WaMessageCoordinator {
+    constructor(deps) {
+        this.messageDispatch = deps.messageDispatch;
+        this.mediaTransfer = deps.mediaTransfer;
+        this.logger = deps.logger;
+        this.messageStore = deps.messageStore;
+        this.messageSecretStore = deps.messageSecretStore;
+        this.trustedContactToken = deps.trustedContactToken;
+        this.emitAddon = deps.emitAddon;
+        this.mexSocket = deps.mexSocket;
+        this.peerDataOperation = deps.peerDataOperation;
+    }
+    /**
+     * Asks the server to backfill older messages for `chatJid` beyond what
+     * arrived in the initial history-sync. Implemented as a
+     * `PeerDataOperationRequestMessage` (type `HISTORY_SYNC_ON_DEMAND`)
+     * sent to this account's own user JID; the response arrives later as
+     * a `history_sync_chunk` event the same way the bootstrap chunks do -
+     * subscribe before calling if you need to react to the chunk.
+     *
+     * The method returns once the request is dispatched (with the protocol
+     * message id), **not** when the chunk arrives. Pair `oldestMsgId` +
+     * `oldestMsgTimestampMs` + `oldestMsgFromMe` from the topmost message
+     * currently visible to page backwards correctly.
+     */
+    async requestHistorySync(input) {
+        const chatJid = normalizeRecipientJid(input.chatJid);
+        if (input.count !== undefined) {
+            if (!Number.isFinite(input.count) ||
+                !Number.isSafeInteger(input.count) ||
+                input.count <= 0) {
+                throw new Error(`invalid count: ${input.count}`);
+            }
+        }
+        if (input.oldestMsgTimestampMs !== undefined) {
+            if (!Number.isFinite(input.oldestMsgTimestampMs) ||
+                !Number.isSafeInteger(input.oldestMsgTimestampMs) ||
+                input.oldestMsgTimestampMs < 0) {
+                throw new Error(`invalid oldestMsgTimestampMs: ${input.oldestMsgTimestampMs}`);
+            }
+        }
+        const historySyncOnDemandRequest = {
+            chatJid,
+            supportInlineResponse: true,
+            ...(input.oldestMsgId === undefined ? {} : { oldestMsgId: input.oldestMsgId }),
+            ...(input.oldestMsgFromMe === undefined
+                ? {}
+                : { oldestMsgFromMe: input.oldestMsgFromMe }),
+            ...(input.oldestMsgTimestampMs === undefined
+                ? {}
+                : { oldestMsgTimestampMs: input.oldestMsgTimestampMs }),
+            ...(input.count === undefined ? {} : { onDemandMsgCount: input.count })
+        };
+        return this.peerDataOperation.send(proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND, { historySyncOnDemandRequest });
+    }
+    /**
+     * Fetches the server-side "reachout" timelock that throttles cold outreach
+     * to non-contacts, returning the active window when enforcement is on.
+     */
+    async getReachoutTimelock() {
+        const data = await runMexQuery(this.mexSocket, 'FetchReachoutTimelock', {});
+        return parseReachoutTimelockMexResponse(data);
+    }
+    /**
+     * Fetches the per-cycle message capping info applied to new-chat threads
+     * (quota, used, cycle boundaries, status flags).
+     */
+    async getNewChatMessageCapping(type = 'INDIVIDUAL_NEW_CHAT_THREAD') {
+        const data = await runMexQuery(this.mexSocket, 'FetchNewChatMessageCappingInfo', {
+            input: { type }
+        });
+        return parseMessageCappingMexResponse(data);
+    }
+    /**
+     * Force-refreshes the Signal session(s) for `jid`. Set `reasonIdentity` to
+     * `true` when the trigger was an identity change – this also queues a
+     * trusted-contact-token reissue.
+     */
+    async syncSignalSession(jid, reasonIdentity = false) {
+        await this.messageDispatch.syncSignalSession(jid, reasonIdentity);
+        if (reasonIdentity) {
+            this.trustedContactToken.reissueOnIdentityChange(jid).catch((err) => this.logger.warn('tc token reissue on identity change failed', {
+                jid,
+                message: toError(err).message
+            }));
+        }
+    }
+    /**
+     * Sends a message (any {@link WaSendMessageContent} kind – text, media,
+     * poll, reaction, edit, revoke, etc.) to `to` and returns the publish
+     * result containing the stanza id and ack metadata.
+     *
+     * `to` accepts any JID accepted by {@link normalizeRecipientJid}: bare
+     * digits (`'5511999999999'`), a phone JID (`'5511…@s.whatsapp.net'`),
+     * a group JID (`'…@g.us'`), or a LID. See the {@link WaSendMessageContent}
+     * union for the full kind list.
+     *
+     * **Gotchas:**
+     * - The stanza id is auto-generated unless you set `options.id`. Reusing
+     *   an id manually makes the send idempotent on the server but is also how
+     *   internal retries (`maxAttempts`) work – don't reuse ids across
+     *   logically distinct messages.
+     * - Sending to a `@newsletter` JID routes through a separate code path
+     *   that ignores most of `options` (no quote/forward/edit semantics).
+     * - Addon-crypto kinds (poll-vote, reaction, message-edit, ...) require an
+     *   authenticated session (`meJid` present) – throws otherwise.
+     * - Group sends fan out to every cached member device. If your
+     *   `groupMetadata` cache is empty/disabled, this triggers a metadata IQ
+     *   per send (rate-limited server-side, see {@link WaCreateStoreOptions}).
+     *
+     * @example
+     * ```ts
+     * // 1. Plain text (string shorthand)
+     * await client.message.send('5511999999999', 'hello!')
+     *
+     * // 2. Reply with mention
+     * await client.message.send(groupJid, {
+     *     type: 'text',
+     *     text: '@5511999999999 ping',
+     *     contextInfo: {
+     *         mentionedJid: ['5511999999999@s.whatsapp.net'],
+     *         quoted: { key: { remoteJid: groupJid, fromMe: false, id: incomingId } }
+     *     }
+     * })
+     *
+     * // 3. Image from a file path (the encoder opens + streams it for you)
+     * await client.message.send(jid, {
+     *     type: 'image',
+     *     media: '/tmp/photo.jpg',
+     *     mimetype: 'image/jpeg',
+     *     caption: 'check this out'
+     * })
+     *
+     * // 4. React to an incoming message (empty emoji = unreact)
+     * await client.message.send(event.key.remoteJid, {
+     *     type: 'reaction',
+     *     emoji: '👍',
+     *     target: event.key // or pass the whole event
+     * })
+     *
+     * // 5. Poll
+     * const result = await client.message.send(jid, {
+     *     type: 'poll',
+     *     name: 'lunch?',
+     *     options: ['pizza', 'sushi', 'burger'],
+     *     selectableCount: 1
+     * })
+     * console.log('sent as', result.id)
+     * ```
+     */
+    send(to, content, options = {}) {
+        return this.messageDispatch.sendMessage(to, content, options);
+    }
+    async sendReceipt(first, second, third) {
+        if (typeof first === 'string') {
+            const ids = second;
+            await this.dispatchReceipt(first, ids, third ?? {});
+            return;
+        }
+        const events = Array.isArray(first) ? first : [first];
+        const options = second ?? {};
+        const targets = events.map((event) => {
+            if (!event.key.remoteJid || !event.key.id) {
+                throw new Error('sendReceipt event is missing key.remoteJid or key.id');
+            }
+            const senderJid = event.key.participant ?? event.key.remoteJid;
+            return {
+                chatJid: event.key.remoteJid,
+                id: event.key.id,
+                senderJid: senderJid
+                    ? applyDeviceToJid(senderJid, event.key.senderDevice)
+                    : undefined,
+                isGroupChat: event.key.isGroup,
+                isBroadcastChat: event.key.isBroadcast
+            };
+        });
+        for (const group of aggregateReceiptTargets(targets)) {
+            await this.dispatchReceipt(group.jid, group.ids, {
+                ...options,
+                participant: group.participant
+            });
+        }
+    }
+    /**
+     * Resolves the media payload inside `source` and returns a `Readable`
+     * stream of the decrypted bytes. Throws when the message has no
+     * downloadable media.
+     *
+     * **Caller owns the stream** - pipe it somewhere or call `.destroy()` to
+     * release the underlying socket; an unconsumed stream leaks the connection.
+     * MAC + SHA-256 verification runs **as bytes are consumed**, so if you
+     * abort mid-read you've consumed unverified bytes. Pass `options.signal`
+     * to cancel cleanly, or use {@link downloadBytes} / {@link downloadToFile}
+     * for one-shot verified downloads.
+     */
+    async download(source, options = {}) {
+        const message = 'rawNode' in source ? source.message : source;
+        const payload = resolveMediaPayload(message);
+        if (!payload) {
+            throw new Error('message has no downloadable media');
+        }
+        const { plaintext, metadata } = await this.mediaTransfer.downloadAndDecryptStream({
+            directPath: payload.directPath,
+            mediaType: payload.mediaType,
+            mediaKey: payload.mediaKey,
+            fileSha256: payload.fileSha256,
+            fileEncSha256: payload.fileEncSha256,
+            timeoutMs: options.timeoutMs,
+            signal: options.signal,
+            maxBytes: options.maxBytes
+        });
+        metadata.catch(() => undefined);
+        return plaintext;
+    }
+    /**
+     * Convenience wrapper around {@link download} that streams the decrypted
+     * media directly to `filePath`. On failure the **partial file is not
+     * cleaned up** - delete it yourself in the error handler if you don't
+     * want to leak corrupted artifacts.
+     */
+    async downloadToFile(source, filePath, options = {}) {
+        const stream = await this.download(source, options);
+        await pipeline(stream, createWriteStream(filePath));
+    }
+    /**
+     * Convenience wrapper around {@link download} that buffers the decrypted
+     * media into a single `Uint8Array`. Use only for small media – caps via
+     * `options.maxBytes`.
+     */
+    async downloadBytes(source, options = {}) {
+        const stream = await this.download(source, options);
+        return readAllBytes(stream, { maxBytes: options.maxBytes });
+    }
+    /**
+     * Attempts to decrypt an addon payload (poll vote, reaction, edit, ...)
+     * attached to `event` and, on success, emits a typed
+     * `WaIncomingAddonEvent`. Silently returns when the parent message
+     * secret is missing or the payload is not an addon.
+     *
+     * Called automatically by the client unless `options.addons.autoDecrypt`
+     * is explicitly `false` - you rarely need to invoke it directly. The
+     * parent secret is looked up in the in-memory `messageSecret` cache
+     * first, then in the `messages` store. If both are `'none'`/missing,
+     * decryption fails and the event never fires; failures are logged at
+     * `warn` for `secretEncryptedMessage` addons (whose parent can be
+     * any message type, so the secret is only available when the
+     * `messages` mailbox is active) and at `debug` for the dedicated
+     * addon types (reactions, poll votes, event responses, comments)
+     * whose parent always carries a persisted secret or is itself
+     * short-lived.
+     */
+    async tryDecryptAddon(event) {
+        const message = event.message;
+        if (!message)
+            return;
+        const addon = identifyEncryptedAddon(message);
+        if (!addon)
+            return;
+        const targetMessageId = addon.targetMessageKey.id;
+        if (!targetMessageId)
+            return;
+        const parentEntry = await resolveParentMessageSecret(targetMessageId, this.messageSecretStore, this.messageStore);
+        if (!parentEntry) {
+            const logCtx = {
+                id: event.key.id,
+                targetId: targetMessageId,
+                kind: addon.kind
+            };
+            if (unwrapMessage(message).secretEncryptedMessage) {
+                this.logger.warn('addon parent message secret not found - enable the `messages` mailbox to support decryption of secretEncryptedMessage addons on arbitrary parents', logCtx);
+            }
+            else {
+                this.logger.debug('addon parent message secret not found', logCtx);
+            }
+            return;
+        }
+        const parentMsgOriginalSender = parentEntry.senderJid;
+        const modificationSender = event.key.participant ?? event.key.remoteJid;
+        const plaintext = await decryptAddonPayload({
+            messageSecret: parentEntry.secret,
+            stanzaId: targetMessageId,
+            parentMsgOriginalSender,
+            modificationSender,
+            modificationType: addon.modificationType,
+            ciphertext: addon.encPayload,
+            iv: addon.encIv,
+            additionalData: shouldUseAddonAdditionalData(addon.modificationType)
+                ? buildAddonAdditionalData(targetMessageId, modificationSender)
+                : undefined
+        });
+        let decrypted = decodeAddonPlaintext(addon.kind, plaintext);
+        if (decrypted.kind === 'poll_vote' && decrypted.pollVote.selectedOptions) {
+            const names = await resolvePollOptionNames(decrypted.pollVote.selectedOptions, targetMessageId, this.messageStore);
+            if (names) {
+                decrypted = { ...decrypted, selectedOptionNames: names };
+            }
+        }
+        this.emitAddon({
+            rawNode: event.rawNode,
+            key: event.key,
+            stanzaType: event.stanzaType,
+            offline: event.offline,
+            kind: addon.kind,
+            targetMessageId,
+            decrypted,
+            raw: message
+        });
+    }
+    dispatchReceipt(jid, ids, options) {
+        const idArray = typeof ids === 'string' ? [ids] : ids;
+        if (idArray.length === 0) {
+            throw new Error('sendReceipt requires at least one message id');
+        }
+        const [id, ...rest] = idArray;
+        const input = {
+            ...options,
+            to: jid,
+            id,
+            listIds: rest.length > 0 ? rest : undefined
+        };
+        return this.messageDispatch.sendReceipt(input);
+    }
+}