zapo-js 0.1.1 → 0.2.0

package/dist/message/ack.js

@@ -31,22 +31,22 @@ function isRetryableNegativeAck(node) {
     return false;
 }
 function describeAckNode(node) {
-    const parts = [`tag=${node.tag}`];
+    let description = `tag=${node.tag}`;
     const id = node.attrs.id;
     const type = node.attrs.type;
     const ackClass = node.attrs.class;
     const code = node.attrs.code;
     if (id) {
-        parts.push(`id=${id}`);
+        description += ` id=${id}`;
     }
     if (type) {
-        parts.push(`type=${type}`);
+        description += ` type=${type}`;
     }
     if (ackClass) {
-        parts.push(`class=${ackClass}`);
+        description += ` class=${ackClass}`;
     }
     if (code) {
-        parts.push(`code=${code}`);
+        description += ` code=${code}`;
     }
-    return parts.join(' ');
+    return description;
 }

package/dist/message/addon-crypto.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseAddonAdditionalData = shouldUseAddonAdditionalData;
+exports.buildAddonAdditionalData = buildAddonAdditionalData;
+exports.encryptAddonPayload = encryptAddonPayload;
+exports.decryptAddonPayload = decryptAddonPayload;
+const _crypto_1 = require("../crypto/index.js");
+const use_case_secret_1 = require("./use-case-secret");
+const bytes_1 = require("../util/bytes");
+const WA_ADDON_ENCRYPTION_NONCE_BYTES = 12;
+function shouldUseAddonAdditionalData(modificationType) {
+    return (modificationType === use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE ||
+        modificationType === use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE);
+}
+function buildAddonAdditionalData(stanzaId, addOnSenderJid) {
+    if (!stanzaId.trim()) {
+        throw new Error('stanza id must be a non-empty string');
+    }
+    if (!addOnSenderJid.trim()) {
+        throw new Error('addon sender jid must be a non-empty string');
+    }
+    return bytes_1.TEXT_ENCODER.encode(`${stanzaId}\u0000${addOnSenderJid}`);
+}
+async function encryptAddonPayload(input) {
+    const secret = await (0, use_case_secret_1.createUseCaseSecret)({
+        messageSecret: (0, use_case_secret_1.assertMessageSecret)(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await (0, _crypto_1.importAesGcmKey)(secret, ['encrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return (0, _crypto_1.aesGcmEncrypt)(key, iv, (0, bytes_1.toBytesView)(input.payload), additionalData);
+}
+async function decryptAddonPayload(input) {
+    const secret = await (0, use_case_secret_1.createUseCaseSecret)({
+        messageSecret: (0, use_case_secret_1.assertMessageSecret)(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await (0, _crypto_1.importAesGcmKey)(secret, ['decrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return (0, _crypto_1.aesGcmDecrypt)(key, iv, (0, bytes_1.toBytesView)(input.ciphertext), additionalData);
+}
+function assertAddonIv(iv) {
+    const normalized = (0, bytes_1.toBytesView)(iv);
+    if (normalized.byteLength !== WA_ADDON_ENCRYPTION_NONCE_BYTES) {
+        throw new Error(`addon iv must be ${WA_ADDON_ENCRYPTION_NONCE_BYTES} bytes (got ${normalized.byteLength})`);
+    }
+    return normalized;
+}
+function resolveAddonAdditionalData(input) {
+    if (input.additionalData) {
+        return (0, bytes_1.toBytesView)(input.additionalData);
+    }
+    if (!shouldUseAddonAdditionalData(input.modificationType)) {
+        return bytes_1.EMPTY_BYTES;
+    }
+    return buildAddonAdditionalData(input.stanzaId, input.modificationSender);
+}

package/dist/message/content.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSendMediaMessage = isSendMediaMessage;
 exports.resolveMessageTypeAttr = resolveMessageTypeAttr;
+exports.resolveEditAttr = resolveEditAttr;
+exports.resolveEncMediaType = resolveEncMediaType;
+exports.resolveMetaAttrs = resolveMetaAttrs;
+const _proto_1 = require("../proto.js");
+const constants_1 = require("../protocol/constants");
 function isSendMediaMessage(content) {
     return (!!content &&
         typeof content === 'object' &&
@@ -9,16 +14,200 @@ 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;
+    }
+}
 function resolveMessageTypeAttr(message) {
-    if (message.reactionMessage) {
-        return 'reaction';
+    const msg = unwrapMessage(message);
+    if (msg.reactionMessage || msg.encReactionMessage) {
+        return constants_1.WA_STANZA_MSG_TYPES.REACTION;
+    }
+    if (msg.eventMessage ||
+        msg.encEventResponseMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        return constants_1.WA_STANZA_MSG_TYPES.EVENT;
+    }
+    if (msg.pollCreationMessage ||
+        msg.pollCreationMessageV2 ||
+        msg.pollCreationMessageV3 ||
+        msg.pollCreationMessageV5 ||
+        msg.pollUpdateMessage ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        return constants_1.WA_STANZA_MSG_TYPES.POLL;
+    }
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return constants_1.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_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT ||
+        msg.secretEncryptedMessage?.secretEncType ===
+            _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_SCHEDULE) {
+        return constants_1.WA_STANZA_MSG_TYPES.TEXT;
+    }
+    return constants_1.WA_STANZA_MSG_TYPES.MEDIA;
+}
+const REVOKED_REACTION_TEXT = '';
+function resolveEditAttr(message, subtype) {
+    const msg = unwrapMessage(message);
+    if (msg.protocolMessage) {
+        const protocolType = msg.protocolMessage.type;
+        if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.REVOKE) {
+            return subtype === 'admin_revoke'
+                ? constants_1.WA_EDIT_ATTRS.ADMIN_REVOKE
+                : constants_1.WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT) {
+            return constants_1.WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+        return null;
+    }
+    if (msg.secretEncryptedMessage) {
+        const encType = msg.secretEncryptedMessage.secretEncType;
+        if (encType === _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT ||
+            encType === _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT) {
+            return constants_1.WA_EDIT_ATTRS.MESSAGE_EDIT;
+        }
+    }
+    if (msg.editedMessage) {
+        return constants_1.WA_EDIT_ATTRS.MESSAGE_EDIT;
+    }
+    if (msg.reactionMessage) {
+        if (msg.reactionMessage.text === REVOKED_REACTION_TEXT) {
+            return constants_1.WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.keepInChatMessage) {
+        if (msg.keepInChatMessage.key?.fromMe === true &&
+            msg.keepInChatMessage.keepType === _proto_1.proto.KeepType.UNDO_KEEP_FOR_ALL) {
+            return constants_1.WA_EDIT_ATTRS.SENDER_REVOKE;
+        }
+        return null;
+    }
+    if (msg.pinInChatMessage) {
+        return constants_1.WA_EDIT_ATTRS.PIN_IN_CHAT;
+    }
+    return null;
+}
+function resolveEncMediaType(message) {
+    const msg = unwrapMessage(message);
+    if (msg.imageMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.IMAGE;
+    if (msg.stickerMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.STICKER;
+    if (msg.locationMessage) {
+        return msg.locationMessage.isLive
+            ? constants_1.WA_ENC_MEDIA_TYPES.LIVE_LOCATION
+            : constants_1.WA_ENC_MEDIA_TYPES.LOCATION;
+    }
+    if (msg.contactMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.VCARD;
+    if (msg.contactsArrayMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.CONTACT_ARRAY;
+    if (msg.documentMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.DOCUMENT;
+    if (msg.audioMessage) {
+        return msg.audioMessage.ptt ? constants_1.WA_ENC_MEDIA_TYPES.PTT : constants_1.WA_ENC_MEDIA_TYPES.AUDIO;
+    }
+    if (msg.videoMessage) {
+        return msg.videoMessage.gifPlayback ? constants_1.WA_ENC_MEDIA_TYPES.GIF : constants_1.WA_ENC_MEDIA_TYPES.VIDEO;
+    }
+    if (msg.ptvMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.PTV;
+    if (msg.buttonsMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.BUTTON;
+    if (msg.buttonsResponseMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.BUTTON_RESPONSE;
+    if (msg.listMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.LIST;
+    if (msg.listResponseMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.LIST_RESPONSE;
+    if (msg.orderMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.ORDER;
+    if (msg.productMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.PRODUCT;
+    if (msg.groupInviteMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.URL;
+    if (msg.interactiveResponseMessage)
+        return constants_1.WA_ENC_MEDIA_TYPES.NATIVE_FLOW_RESPONSE;
+    if (msg.messageHistoryBundle)
+        return constants_1.WA_ENC_MEDIA_TYPES.GROUP_HISTORY;
+    if (msg.extendedTextMessage?.matchedText && msg.extendedTextMessage.matchedText.trim() !== '') {
+        return constants_1.WA_ENC_MEDIA_TYPES.URL;
+    }
+    return null;
+}
+function resolveMetaAttrs(message) {
+    const msg = unwrapMessage(message);
+    let polltype;
+    let eventType;
+    let viewOnce;
+    if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3) {
+        polltype = constants_1.WA_POLL_META_TYPES.CREATION;
+    }
+    else if (msg.pollUpdateMessage) {
+        polltype = constants_1.WA_POLL_META_TYPES.VOTE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_EDIT) {
+        polltype = constants_1.WA_POLL_META_TYPES.EDIT;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.POLL_ADD_OPTION) {
+        polltype = constants_1.WA_POLL_META_TYPES.EDIT;
+    }
+    if (msg.eventMessage) {
+        eventType = constants_1.WA_EVENT_META_TYPES.CREATION;
+    }
+    else if (msg.encEventResponseMessage) {
+        eventType = constants_1.WA_EVENT_META_TYPES.RESPONSE;
+    }
+    else if (msg.secretEncryptedMessage?.secretEncType ===
+        _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.EVENT_EDIT) {
+        eventType = constants_1.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;
 }

package/dist/message/icdc.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDeviceKeyHash = computeDeviceKeyHash;
+exports.resolveIcdcMeta = resolveIcdcMeta;
+exports.injectDeviceListMetadata = injectDeviceListMetadata;
+const _crypto_1 = require("../crypto/index.js");
+const jid_1 = require("../protocol/jid");
+const bytes_1 = require("../util/bytes");
+const ICDC_HASH_LENGTH = 8;
+const ICDC_FRESHNESS_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
+const DEVICE_LIST_METADATA_VERSION = 2;
+const EMPTY_KEY_HASH = new Uint8Array(ICDC_HASH_LENGTH);
+async function computeDeviceKeyHash(identityKeys) {
+    if (identityKeys.length === 0) {
+        return EMPTY_KEY_HASH;
+    }
+    const rawKeys = new Array(identityKeys.length);
+    for (let i = 0; i < identityKeys.length; i += 1) {
+        rawKeys[i] =
+            identityKeys[i].byteLength === 33 ? (0, _crypto_1.toRawPubKey)(identityKeys[i]) : identityKeys[i];
+    }
+    const combined = (0, bytes_1.concatBytes)(rawKeys);
+    const hash = await (0, _crypto_1.sha256)(combined);
+    return hash.subarray(0, ICDC_HASH_LENGTH);
+}
+async function resolveIcdcMeta(deviceJids, signalStore, updatedAtMs, localIdentity) {
+    if (deviceJids.length === 0) {
+        return null;
+    }
+    const addresses = new Array(deviceJids.length);
+    for (let i = 0; i < deviceJids.length; i += 1) {
+        addresses[i] = (0, jid_1.parseSignalAddressFromJid)(deviceJids[i]);
+    }
+    const remoteKeys = await signalStore.getRemoteIdentities(addresses);
+    const keys = [];
+    for (let i = 0; i < addresses.length; i += 1) {
+        const key = remoteKeys[i];
+        if (key) {
+            keys.push(key);
+        }
+        else if (localIdentity &&
+            addresses[i].user === localIdentity.address.user &&
+            addresses[i].device === localIdentity.address.device) {
+            keys.push(localIdentity.pubKey);
+        }
+    }
+    if (keys.length === 0) {
+        return null;
+    }
+    const keyHash = await computeDeviceKeyHash(keys);
+    const timestamp = updatedAtMs !== undefined && Date.now() - updatedAtMs < ICDC_FRESHNESS_THRESHOLD_MS
+        ? Math.floor(updatedAtMs / 1000)
+        : undefined;
+    return { keyHash, timestamp };
+}
+function injectDeviceListMetadata(message, senderIcdc, recipientIcdc) {
+    if (!senderIcdc && !recipientIcdc) {
+        return message;
+    }
+    const deviceListMetadata = {};
+    if (senderIcdc) {
+        deviceListMetadata.senderKeyHash = senderIcdc.keyHash;
+        if (senderIcdc.timestamp !== undefined) {
+            deviceListMetadata.senderTimestamp = senderIcdc.timestamp;
+        }
+    }
+    if (recipientIcdc) {
+        deviceListMetadata.recipientKeyHash = recipientIcdc.keyHash;
+        if (recipientIcdc.timestamp !== undefined) {
+            deviceListMetadata.recipientTimestamp = recipientIcdc.timestamp;
+        }
+    }
+    return {
+        ...message,
+        messageContextInfo: {
+            ...message.messageContextInfo,
+            deviceListMetadata,
+            deviceListMetadataVersion: DEVICE_LIST_METADATA_VERSION
+        }
+    };
+}