zapo-js 0.1.2 → 0.2.0

package/dist/esm/media/WaMediaCrypto.js

@@ -1,12 +1,16 @@
 import { createCipheriv, createDecipheriv, createHash, createHmac } from 'node:crypto';
 import { once } from 'node:events';
+import { createWriteStream } from 'node:fs';
+import { stat, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { PassThrough } from 'node:stream';
 import { hkdf } from '../crypto/core/hkdf.js';
 import { aesCbcDecrypt, aesCbcEncrypt, hmacSign, importAesCbcKey, importHmacKey, sha256 } from '../crypto/core/primitives.js';
 import { randomBytesAsync } from '../crypto/core/random.js';
 import { ENC_KEY_END, ENC_KEY_START, HMAC_TRUNCATED_SIZE, IV_SIZE, MAC_KEY_END, MAC_KEY_START, MEDIA_HKDF_SIZE } from './constants.js';
 import { WA_APP_STATE_KEY_TYPES, getWaMediaHkdfInfo } from '../protocol/constants.js';
-import { assertByteLength, concatBytes, EMPTY_BYTES, readAllBytes, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
+import { assertByteLength, concatBytes, EMPTY_BYTES, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 export class WaMediaCrypto {
     static async generateMediaKey() {
@@ -77,17 +81,22 @@ export class WaMediaCrypto {
         const metadata = pumpEncryption(plaintext, encrypted, keys);
         return { encrypted, metadata };
     }
-    static async decryptReadableToBytes(encrypted, options) {
-        const decrypted = await WaMediaCrypto.decryptReadable(encrypted, options);
-        const [plaintext, metadata] = await Promise.all([
-            readAllBytes(decrypted.plaintext),
-            decrypted.metadata
-        ]);
-        return {
-            plaintext,
-            fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
-        };
+    static async encryptToFile(mediaType, mediaKey, plaintext) {
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const filePath = join(tmpdir(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        const output = createWriteStream(filePath);
+        try {
+            const metadata = await pumpEncryptionToWritable(plaintext, output, keys);
+            const fileSize = (await stat(filePath)).size;
+            return { filePath, fileSize, ...metadata };
+        }
+        catch (error) {
+            await unlink(filePath).catch(() => undefined);
+            throw error;
+        }
+    }
+    static async cleanupEncryptedFile(filePath) {
+        await unlink(filePath).catch(() => undefined);
     }
     static async decryptReadable(encrypted, options) {
         const keys = await WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
@@ -108,6 +117,7 @@ async function pumpEncryption(plaintext, encrypted, keys) {
     const encHash = createHash('sha256');
     const hmac = createHmac('sha256', keys.macKey);
     const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
     hmac.update(keys.iv);
     try {
         for await (const chunk of plaintext) {
@@ -115,6 +125,7 @@ async function pumpEncryption(plaintext, encrypted, keys) {
             if (plainChunk.byteLength === 0) {
                 continue;
             }
+            plaintextLength += plainChunk.byteLength;
             plainHash.update(plainChunk);
             const encryptedChunk = cipher.update(plainChunk);
             if (encryptedChunk.byteLength > 0) {
@@ -135,7 +146,8 @@ async function pumpEncryption(plaintext, encrypted, keys) {
         encrypted.end();
         return {
             fileSha256: toBytesView(plainHash.digest()),
-            fileEncSha256: toBytesView(encHash.digest())
+            fileEncSha256: toBytesView(encHash.digest()),
+            plaintextLength
         };
     }
     catch (error) {
@@ -144,6 +156,76 @@ async function pumpEncryption(plaintext, encrypted, keys) {
         throw normalized;
     }
 }
+async function writeChunkToWritable(stream, chunk) {
+    if (chunk.byteLength === 0) {
+        return;
+    }
+    if (stream.write(chunk)) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const onDrain = () => {
+            stream.off('error', onError);
+            resolve();
+        };
+        const onError = (err) => {
+            stream.off('drain', onDrain);
+            reject(err);
+        };
+        stream.once('drain', onDrain);
+        stream.once('error', onError);
+    });
+}
+async function endWritable(stream) {
+    return new Promise((resolve, reject) => {
+        stream.on('error', reject);
+        stream.end(() => resolve());
+    });
+}
+async function pumpEncryptionToWritable(plaintext, output, keys) {
+    const plainHash = createHash('sha256');
+    const encHash = createHash('sha256');
+    const hmac = createHmac('sha256', keys.macKey);
+    const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
+    hmac.update(keys.iv);
+    try {
+        for await (const chunk of plaintext) {
+            const plainChunk = toChunkBytes(chunk);
+            if (plainChunk.byteLength === 0) {
+                continue;
+            }
+            plaintextLength += plainChunk.byteLength;
+            plainHash.update(plainChunk);
+            const encryptedChunk = cipher.update(plainChunk);
+            if (encryptedChunk.byteLength > 0) {
+                hmac.update(encryptedChunk);
+                encHash.update(encryptedChunk);
+                await writeChunkToWritable(output, encryptedChunk);
+            }
+        }
+        const encryptedFinal = cipher.final();
+        if (encryptedFinal.byteLength > 0) {
+            hmac.update(encryptedFinal);
+            encHash.update(encryptedFinal);
+            await writeChunkToWritable(output, encryptedFinal);
+        }
+        const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
+        encHash.update(signature);
+        await writeChunkToWritable(output, signature);
+        await endWritable(output);
+        return {
+            fileSha256: toBytesView(plainHash.digest()),
+            fileEncSha256: toBytesView(encHash.digest()),
+            plaintextLength
+        };
+    }
+    catch (error) {
+        const normalized = toError(error);
+        output.destroy(normalized);
+        throw normalized;
+    }
+}
 async function pumpDecryption(encrypted, plaintext, keys, options) {
     const plainHash = createHash('sha256');
     const encHash = createHash('sha256');

package/dist/esm/media/WaMediaTransferClient.js

@@ -86,14 +86,16 @@ export class WaMediaTransferClient {
             urls: urls.length,
             timeoutMs
         });
-        return this.executeTransfer(urls, timeoutMs, request.signal, {
-            responseLog: 'media download stream response',
-            send: (url, signal) => this.transferRequest(url, {
-                method: 'GET',
-                headers,
-                signal
-            }, dispatcher, agent)
+        const result = await this.fetchWithFallback(urls, timeoutMs, request.signal, (url, signal) => this.transferRequest(url, {
+            method: 'GET',
+            headers,
+            signal
+        }, dispatcher, agent));
+        this.logger?.trace('media download stream response', {
+            url: result.url,
+            status: result.status
         });
+        return result;
     }
     async downloadBytes(request) {
         const response = await this.downloadStream(request);
@@ -101,7 +103,9 @@ export class WaMediaTransferClient {
         if (!response.body) {
             return EMPTY_BYTES;
         }
-        return this.readAllBytesWithLimit(response.body, request.maxBytes);
+        return readAllBytes(response.body, {
+            maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+        });
     }
     async uploadStream(request) {
         const bodyIsBytes = request.body instanceof Uint8Array;
@@ -125,26 +129,28 @@ export class WaMediaTransferClient {
             timeoutMs,
             method
         });
-        return this.executeTransfer(uploadUrls, timeoutMs, request.signal, {
-            responseLog: 'media upload stream response',
-            send: async (url, signal) => {
-                if (bodyIsBytes) {
-                    return this.transferRequest(url, {
-                        method,
-                        headers,
-                        signal,
-                        body: request.body
-                    }, dispatcher, agent);
-                }
+        const result = await this.fetchWithFallback(uploadUrls, timeoutMs, request.signal, async (url, signal) => {
+            if (bodyIsBytes) {
                 return this.transferRequest(url, {
                     method,
                     headers,
                     signal,
-                    body: request.body,
-                    duplex: 'half'
+                    body: request.body
                 }, dispatcher, agent);
             }
+            return this.transferRequest(url, {
+                method,
+                headers,
+                signal,
+                body: request.body,
+                duplex: 'half'
+            }, dispatcher, agent);
+        });
+        this.logger?.trace('media upload stream response', {
+            url: result.url,
+            status: result.status
         });
+        return result;
     }
     async uploadEncrypted(request) {
         this.logger?.info('media encrypted upload start', {
@@ -181,7 +187,8 @@ export class WaMediaTransferClient {
             transfer,
             mediaKey,
             fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
+            fileEncSha256: metadata.fileEncSha256,
+            plaintextLength: metadata.plaintextLength
         };
     }
     async downloadAndDecrypt(request) {
@@ -190,8 +197,12 @@ export class WaMediaTransferClient {
         });
         const decrypted = await this.downloadAndDecryptStream(request);
         try {
-            const plaintext = await this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes);
-            await decrypted.metadata;
+            const [plaintext] = await Promise.all([
+                readAllBytes(decrypted.plaintext, {
+                    maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+                }),
+                decrypted.metadata
+            ]);
             this.logger?.info('media encrypted download completed', {
                 byteLength: plaintext.byteLength
             });
@@ -225,7 +236,7 @@ export class WaMediaTransferClient {
         if (!response.body) {
             return EMPTY_BYTES;
         }
-        return this.readAllBytesWithLimit(response.body, maxBytes);
+        return readAllBytes(response.body, { maxBytes: maxBytes ?? this.defaultMaxReadBytes });
     }
     async transferRequest(url, init, dispatcher, agent) {
         if (agent) {
@@ -246,7 +257,7 @@ export class WaMediaTransferClient {
         return {
             status: response.status,
             ok: response.ok,
-            headers: this.headersToRecord(response.headers),
+            headers: Object.fromEntries(response.headers.entries()),
             body: response.body
                 ? Readable.fromWeb(response.body)
                 : null,
@@ -362,14 +373,6 @@ export class WaMediaTransferClient {
             timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs
         };
     }
-    async executeTransfer(urls, timeoutMs, signal, options) {
-        const result = await this.fetchWithFallback(urls, timeoutMs, signal, options.send);
-        this.logger?.trace(options.responseLog, {
-            url: result.url,
-            status: result.status
-        });
-        return result;
-    }
     async prepareEncryptedUpload(request, mediaKey) {
         if (request.plaintext instanceof Uint8Array) {
             const encrypted = await WaMediaCrypto.encryptBytes(request.mediaType, mediaKey, request.plaintext);
@@ -378,7 +381,8 @@ export class WaMediaTransferClient {
                 contentLength: encrypted.ciphertextHmac.byteLength,
                 metadata: Promise.resolve({
                     fileSha256: encrypted.fileSha256,
-                    fileEncSha256: encrypted.fileEncSha256
+                    fileEncSha256: encrypted.fileEncSha256,
+                    plaintextLength: request.plaintext.byteLength
                 }),
                 cleanup: async () => undefined
             };
@@ -432,11 +436,6 @@ export class WaMediaTransferClient {
         }
         return resolved;
     }
-    readAllBytesWithLimit(stream, maxBytes) {
-        return readAllBytes(stream, {
-            maxBytes: maxBytes ?? this.defaultMaxReadBytes
-        });
-    }
     async fetchWithFallback(urls, timeoutMs, signal, send) {
         let lastError = null;
         for (let index = 0; index < urls.length; index += 1) {
@@ -506,13 +505,6 @@ export class WaMediaTransferClient {
             }
         };
     }
-    headersToRecord(headers) {
-        const output = {};
-        headers.forEach((value, key) => {
-            output[key] = value;
-        });
-        return output;
-    }
     async drainBody(body) {
         if (!body) {
             return;

package/dist/esm/media/constants.js

@@ -17,5 +17,6 @@ export const MEDIA_UPLOAD_PATHS = Object.freeze({
     document: '/mms/document',
     sticker: '/mms/sticker',
     gif: '/mms/gif',
-    ptt: '/mms/ptt'
+    ptt: '/mms/ptt',
+    ptv: '/mms/video'
 });

package/dist/esm/message/WaMessageClient.js

@@ -1,5 +1,6 @@
 import { describeAckNode, isAckOrReceiptNode, isNegativeAckNode, isRetryableNegativeAck } from './ack.js';
 import { WA_DEFAULTS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_NODE_TAGS } from '../protocol/constants.js';
+import { buildReceiptNode } from '../transport/node/builders/global.js';
 import { delay } from '../util/async.js';
 import { parseOptionalInt, toError } from '../util/primitives.js';
 const WA_RETRYABLE_PUBLISH_ERROR_RE = /timeout|socket|connection|closed/i;
@@ -112,6 +113,9 @@ export class WaMessageClient {
         if (input.id) {
             attrs.id = input.id;
         }
+        if (input.edit) {
+            attrs.edit = input.edit;
+        }
         if (input.category) {
             attrs.category = input.category;
         }
@@ -131,6 +135,9 @@ export class WaMessageClient {
             v: WA_MESSAGE_TYPES.ENC_VERSION,
             type: input.encType
         };
+        if (input.mediatype) {
+            encAttrs.mediatype = input.mediatype;
+        }
         if (input.encCount !== undefined && input.encCount > 0) {
             encAttrs.count = String(Math.trunc(input.encCount));
         }
@@ -148,6 +155,9 @@ export class WaMessageClient {
                 content: input.deviceIdentity
             });
         }
+        if (input.metaNode) {
+            content.push(input.metaNode);
+        }
         const node = {
             tag: WA_MESSAGE_TAGS.MESSAGE,
             attrs,
@@ -156,29 +166,26 @@ export class WaMessageClient {
         return node;
     }
     async sendReceipt(input) {
-        const attrs = {
+        const node = buildReceiptNode({
+            kind: 'outbound',
             to: input.to,
             id: input.id,
-            type: input.type ?? 'read'
-        };
-        if (input.participant) {
-            attrs.participant = input.participant;
-        }
-        if (input.from) {
-            attrs.from = input.from;
-        }
-        if (input.t) {
-            attrs.t = input.t;
-        }
-        this.logger.debug('sending receipt node', {
-            to: attrs.to,
-            id: attrs.id,
-            type: attrs.type
+            type: input.type ?? 'read',
+            participant: input.participant,
+            recipient: input.recipient,
+            category: input.category,
+            from: input.from,
+            t: input.t,
+            peerParticipantPn: input.peerParticipantPn,
+            listIds: input.listIds,
+            content: input.content ? [...input.content] : undefined
         });
-        await this.sendNode({
-            tag: WA_MESSAGE_TAGS.RECEIPT,
-            attrs
+        this.logger.debug('sending receipt node', {
+            to: node.attrs.to,
+            id: node.attrs.id,
+            type: node.attrs.type
         });
+        await this.sendNode(node);
     }
     isRetryablePublishError(error) {
         return WA_RETRYABLE_PUBLISH_ERROR_RE.test(error.message);

package/dist/esm/message/content.js

@@ -1,3 +1,5 @@
+import { proto } from '../proto.js';
+import { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_POLL_META_TYPES, WA_STANZA_MSG_TYPES } from '../protocol/constants.js';
 export function isSendMediaMessage(content) {
     return (!!content &&
         typeof content === 'object' &&
@@ -5,16 +7,200 @@ export function isSendMediaMessage(content) {
         'media' in content &&
         'mimetype' in content);
 }
+function unwrapMessage(message) {
+    let msg = message;
+    for (;;) {
+        const inner = msg.ephemeralMessage?.message ??
+            msg.groupMentionedMessage?.message ??
+            msg.botInvokeMessage?.message ??
+            msg.deviceSentMessage?.message ??
+            msg.viewOnceMessage?.message ??
+            msg.viewOnceMessageV2?.message ??
+            msg.documentWithCaptionMessage?.message;
+        if (!inner)
+            return msg;
+        msg = inner;
+    }
+}
 export function resolveMessageTypeAttr(message) {
-    if (message.reactionMessage) {
-        return 'reaction';
+    const msg = unwrapMessage(message);
+    if (msg.reactionMessage || msg.encReactionMessage) {
+        return WA_STANZA_MSG_TYPES.REACTION;
+    }
+    if (msg.eventMessage ||
+        msg.encEventResponseMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        return WA_STANZA_MSG_TYPES.EVENT;
+    }
+    if (msg.pollCreationMessage ||
+        msg.pollCreationMessageV2 ||
+        msg.pollCreationMessageV3 ||
+        msg.pollCreationMessageV5 ||
+        msg.pollUpdateMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        return WA_STANZA_MSG_TYPES.POLL;
+    }
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return WA_STANZA_MSG_TYPES.MEDIA;
+    }
+    if ((msg.conversation !== undefined && msg.conversation !== null) ||
+        (msg.extendedTextMessage && !msg.extendedTextMessage.matchedText) ||
+        msg.protocolMessage ||
+        msg.interactiveMessage ||
+        msg.keepInChatMessage ||
+        msg.requestPhoneNumberMessage ||
+        msg.editedMessage ||
+        msg.pinInChatMessage ||
+        msg.encCommentMessage ||
+        msg.newsletterAdminInviteMessage ||
+        msg.pollResultSnapshotMessage ||
+        msg.pollResultSnapshotMessageV3 ||
+        msg.templateButtonReplyMessage ||
+        msg.messageHistoryNotice ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_SCHEDULE) {
+        return WA_STANZA_MSG_TYPES.TEXT;
+    }
+    return WA_STANZA_MSG_TYPES.MEDIA;
+}
+const REVOKED_REACTION_TEXT = '';
+export function resolveEditAttr(message, subtype) {
+    const msg = unwrapMessage(message);
+    if (msg.protocolMessage) {
+        const protocolType = msg.protocolMessage.type;
+        if (protocolType === proto.Message.ProtocolMessage.Type.REVOKE) {
+            return subtype === 'admin_revoke'
+                ? WA_EDIT_ATTRS.ADMIN_REVOKE
+                : WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        if (protocolType === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT) {
+            return WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+        return null;
+    }
+    if (msg.secretEncryptedMessage) {
+        const encType = msg.secretEncryptedMessage.secretEncType;
+        if (encType === proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT ||
+            encType === proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT) {
+            return WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+    }
+    if (msg.editedMessage) {
+        return WA_EDIT_ATTRS.MESSAGE_EDIT;
+    }
+    if (msg.reactionMessage) {
+        if (msg.reactionMessage.text === REVOKED_REACTION_TEXT) {
+            return WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.keepInChatMessage) {
+        if (msg.keepInChatMessage.key?.fromMe === true &&
+            msg.keepInChatMessage.keepType === proto.KeepType.UNDO_KEEP_FOR_ALL) {
+            return WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.pinInChatMessage) {
+        return WA_EDIT_ATTRS.PIN_IN_CHAT;
+    }
+    return null;
+}
+export function resolveEncMediaType(message) {
+    const msg = unwrapMessage(message);
+    if (msg.imageMessage)
+        return WA_ENC_MEDIA_TYPES.IMAGE;
+    if (msg.stickerMessage)
+        return WA_ENC_MEDIA_TYPES.STICKER;
+    if (msg.locationMessage) {
+        return msg.locationMessage.isLive
+            ? WA_ENC_MEDIA_TYPES.LIVE_LOCATION
+            : WA_ENC_MEDIA_TYPES.LOCATION;
+    }
+    if (msg.contactMessage)
+        return WA_ENC_MEDIA_TYPES.VCARD;
+    if (msg.contactsArrayMessage)
+        return WA_ENC_MEDIA_TYPES.CONTACT_ARRAY;
+    if (msg.documentMessage)
+        return WA_ENC_MEDIA_TYPES.DOCUMENT;
+    if (msg.audioMessage) {
+        return msg.audioMessage.ptt ? WA_ENC_MEDIA_TYPES.PTT : WA_ENC_MEDIA_TYPES.AUDIO;
+    }
+    if (msg.videoMessage) {
+        return msg.videoMessage.gifPlayback ? WA_ENC_MEDIA_TYPES.GIF : WA_ENC_MEDIA_TYPES.VIDEO;
+    }
+    if (msg.ptvMessage)
+        return WA_ENC_MEDIA_TYPES.PTV;
+    if (msg.buttonsMessage)
+        return WA_ENC_MEDIA_TYPES.BUTTON;
+    if (msg.buttonsResponseMessage)
+        return WA_ENC_MEDIA_TYPES.BUTTON_RESPONSE;
+    if (msg.listMessage)
+        return WA_ENC_MEDIA_TYPES.LIST;
+    if (msg.listResponseMessage)
+        return WA_ENC_MEDIA_TYPES.LIST_RESPONSE;
+    if (msg.orderMessage)
+        return WA_ENC_MEDIA_TYPES.ORDER;
+    if (msg.productMessage)
+        return WA_ENC_MEDIA_TYPES.PRODUCT;
+    if (msg.groupInviteMessage)
+        return WA_ENC_MEDIA_TYPES.URL;
+    if (msg.interactiveResponseMessage)
+        return WA_ENC_MEDIA_TYPES.NATIVE_FLOW_RESPONSE;
+    if (msg.messageHistoryBundle)
+        return WA_ENC_MEDIA_TYPES.GROUP_HISTORY;
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return WA_ENC_MEDIA_TYPES.URL;
+    }
+    return null;
+}
+export function resolveMetaAttrs(message) {
+    const msg = unwrapMessage(message);
+    let polltype;
+    let eventType;
+    let viewOnce;
+    if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3) {
+        polltype = WA_POLL_META_TYPES.CREATION;
+    }
+    else if (msg.pollUpdateMessage) {
+        polltype = WA_POLL_META_TYPES.VOTE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT) {
+        polltype = WA_POLL_META_TYPES.EDIT;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        polltype = WA_POLL_META_TYPES.EDIT;
+    }
+    if (msg.eventMessage) {
+        eventType = WA_EVENT_META_TYPES.CREATION;
+    }
+    else if (msg.encEventResponseMessage) {
+        eventType = WA_EVENT_META_TYPES.RESPONSE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        eventType = WA_EVENT_META_TYPES.EDIT;
+    }
+    if (message.viewOnceMessage || message.viewOnceMessageV2) {
+        viewOnce = 'true';
     }
-    if (message.imageMessage ||
-        message.videoMessage ||
-        message.audioMessage ||
-        message.documentMessage ||
-        message.stickerMessage) {
-        return 'media';
+    if (!polltype && !eventType && !viewOnce) {
+        return null;
     }
-    return 'text';
+    const attrs = {};
+    if (polltype)
+        attrs.polltype = polltype;
+    if (eventType)
+        attrs.event_type = eventType;
+    if (viewOnce)
+        attrs.view_once = viewOnce;
+    return attrs;
 }