@oxidezap/baileyrs 0.2.7 → 0.2.9

package/README.md

@@ -374,6 +374,29 @@ baileyrs auto-wraps, including `useLegacyMultiFileAuthState`. It does not apply
 to `useMultiFileAuthState`, whose `keys` is a projection over the engine's own
 store; the `bridge-` namespaces never surface through it.
 
+The move back down is not symmetric either. From 0.2.8 on, the core buffers a
+skipped-message key as its seed alone, where an earlier release wrote the
+derived cipher/mac/iv triple beside it. Forward is fine — a record written
+before this carries both, and the newer engine reads it unchanged. Backward is
+not: an older engine cannot parse a record whose skipped keys carry no triple,
+and it fails on **the whole record**, not on the one key.
+
+Where that bites depends on which bytes the engine is handed, and a wrapped
+store is not automatically on the safe side of it. It holds the Baileys
+projection, which has only ever held seeds — but it also mirrors the core's
+exact bytes under `bridge-native-session`, and a read prefers that mirror for as
+long as its fingerprint still matches the projection. A downgrade can therefore
+be handed the newer record with a perfectly readable projection sitting right
+beside it.
+
+Dropping a mirror row makes the next read rebuild it from the projection, which
+is the format both versions agree on — but only for a session that has one. A
+session that turned native-only lives in that row alone, so dropping *that* one
+loses the session outright, which is the case the warning above is about. A
+session with no skipped keys buffered at the time is unaffected either way: the
+difference only exists while a chain is holding keys for messages that arrived
+out of order.
+
 ## Disclaimer
 
 This project is not affiliated with, endorsed by, or in any way officially connected to

package/lib/Compatibility/legacy-store/codecs/basic.js

@@ -102,11 +102,18 @@ function tcTokenCodec() {
         },
         toLegacy(_key, value) {
             const native = fromJsonBytes(value);
-            return {
+            // Added rather than set to `undefined`, matching upstream, which
+            // only carries the field when it has a value. An undefined-valued
+            // key survives in memory but not through a store, and the mirror
+            // fingerprint is taken on both sides of that boundary — see the
+            // note in `canonicalize`.
+            const legacy = {
                 token: Buffer.from(requireByteArray(native.token, 'native TC token')),
-                timestamp: (native.token_timestamp ?? TimeValue.UNKNOWN_SECONDS).toString(),
-                senderTimestamp: native.sender_timestamp == null ? undefined : native.sender_timestamp.toString()
+                timestamp: (native.token_timestamp ?? TimeValue.UNKNOWN_SECONDS).toString()
             };
+            if (native.sender_timestamp != null)
+                legacy.senderTimestamp = native.sender_timestamp.toString();
+            return legacy;
         }
     };
 }

package/lib/Compatibility/legacy-store/codecs/signal.js

@@ -177,7 +177,16 @@ function coreEntryToLegacy(session) {
             messageKeys: messageKeysToLegacy(chain.messageKeys)
         };
     }
-    return {
+    // Both optional parts are *added* rather than set to `undefined`, which is
+    // what upstream does (`session_record.js` guards `if (this.pendingPreKey)`,
+    // `session_builder.js` guards `if (device.preKey)`). The distinction is
+    // invisible once the value reaches a store — JSON drops an undefined-valued
+    // key — but it is visible to the mirror fingerprint, which is taken from
+    // the live object on write and from the reloaded one on read. Emitting the
+    // key made those two disagree for every session without a pending pre-key,
+    // so the mirror was rejected on the next read and the record rebuilt from
+    // the projection, discarding the counter lease the rebuild cannot express.
+    const entry = {
         registrationId: session.registrationId,
         currentRatchet: {
             ephemeralKeyPair: {
@@ -196,15 +205,18 @@ function coreEntryToLegacy(session) {
             created: session.index.createdAtMs,
             remoteIdentityKey: toBase64(session.index.remoteIdentityKey)
         },
-        _chains: chains,
-        pendingPreKey: session.pendingPreKey
-            ? {
-                preKeyId: session.pendingPreKey.preKeyId,
-                signedKeyId: session.pendingPreKey.signedPreKeyId,
-                baseKey: toBase64(session.pendingPreKey.baseKey)
-            }
-            : undefined
+        _chains: chains
     };
+    if (session.pendingPreKey) {
+        entry.pendingPreKey = {
+            signedKeyId: session.pendingPreKey.signedPreKeyId,
+            baseKey: toBase64(session.pendingPreKey.baseKey)
+        };
+        if (session.pendingPreKey.preKeyId !== undefined) {
+            entry.pendingPreKey.preKeyId = session.pendingPreKey.preKeyId;
+        }
+    }
+    return entry;
 }
 function sessionToLegacy(nativeBytes) {
     const projection = projectLegacySessionRecordV1(nativeBytes);

package/lib/Compatibility/legacy-store/common.js

@@ -16,15 +16,29 @@ export const toBytes = (value) => {
     return null;
 };
 export const bytesToNumbers = (value) => Array.from(value);
+/**
+ * Marks a value JSON would not have kept, so the object and array branches can
+ * each drop it the way `JSON.stringify` does. A plain `undefined` return could
+ * not be told apart from a property that is genuinely absent.
+ */
+const ABSENT = Symbol('absent');
 /**
  * Stable, runtime-independent representation used only to notice legacy-side
  * ownership changes. Buffer and Uint8Array intentionally share one shape.
+ *
+ * `undefined` follows `JSON.stringify`, and that is deliberately asymmetric: an
+ * object property is dropped, an array element becomes `null`. The fingerprint
+ * is taken from the live projection when the mirror is written and from the
+ * reloaded one when it is read, so any distinction a store cannot carry makes
+ * the two disagree forever. Tagging `undefined` as its own value was such a
+ * distinction — no persisted store can express it, and the mirror it invalidated
+ * is the only copy of the record fields the projection has no room for.
  */
 function canonicalize(value, seen) {
     if (value === null)
         return null;
     if (value === undefined)
-        return { [CanonicalTag.UNDEFINED]: true };
+        return ABSENT;
     if (typeof value === 'string' || typeof value === 'boolean')
         return value;
     if (typeof value === 'number') {
@@ -51,11 +65,17 @@ function canonicalize(value, seen) {
         throw new TypeError('cannot fingerprint a cyclic legacy store value');
     seen.add(value);
     try {
-        if (Array.isArray(value))
-            return value.map(item => canonicalize(item, seen));
+        if (Array.isArray(value)) {
+            return value.map(item => {
+                const canonical = canonicalize(item, seen);
+                return canonical === ABSENT ? null : canonical;
+            });
+        }
         const out = {};
         for (const key of Object.keys(value).toSorted()) {
-            out[key] = canonicalize(value[key], seen);
+            const canonical = canonicalize(value[key], seen);
+            if (canonical !== ABSENT)
+                out[key] = canonical;
         }
         return out;
     }
@@ -64,8 +84,13 @@ function canonicalize(value, seen) {
     }
 }
 function fingerprintLegacy(value) {
-    const canonical = JSON.stringify(canonicalize(value, new Set()));
-    return createHash(MirrorEnvelope.HASH).update(canonical).digest();
+    // A top-level absent value hashes as `null`: a store reports a row it does
+    // not hold as either, and the two have to agree for the same reason the
+    // property case does.
+    const canonical = canonicalize(value, new Set());
+    return createHash(MirrorEnvelope.HASH)
+        .update(JSON.stringify(canonical === ABSENT ? null : canonical))
+        .digest();
 }
 /** Persist exact native bytes together with the projection generation. */
 export function encodeNativeEnvelope(payload, legacyValue) {

package/lib/Compatibility/legacy-store/constants.d.ts

@@ -101,7 +101,6 @@ export declare const CanonicalTag: Readonly<{
     readonly BYTES: '$bytes';
     readonly DATE: '$date';
     readonly NUMBER: '$number';
-    readonly UNDEFINED: '$undefined';
     readonly UNSUPPORTED: '$unsupported';
 }>;
 export declare const NumericEncoding: Readonly<{

package/lib/Compatibility/legacy-store/constants.js

@@ -99,7 +99,6 @@ export const CanonicalTag = Object.freeze({
     BYTES: '$bytes',
     DATE: '$date',
     NUMBER: '$number',
-    UNDEFINED: '$undefined',
     UNSUPPORTED: '$unsupported'
 });
 export const NumericEncoding = Object.freeze({

package/lib/Socket/events.js

@@ -35,7 +35,17 @@ const emitCBEvents = (ctx, node) => {
     const id = l1.id;
     if (id)
         ws.emit(`${DEF_TAG_PREFIX}${id}`, node);
-    for (const [key, val] of Object.entries(l1)) {
+    // `for..in` over the attrs rather than `Object.entries`: this runs for every
+    // stanza the socket sees and the pair array it built was thrown away
+    // immediately. `Object.entries` was own-only by construction though, and
+    // `BinaryNode` is public, so the walk is guarded rather than trusting every
+    // caller to hand over an attrs map with a bare prototype. An inherited
+    // enumerable would otherwise fire CB events for an attr the stanza does not
+    // carry; the check costs nothing next to the emits below.
+    for (const key in l1) {
+        if (!Object.hasOwn(l1, key))
+            continue;
+        const val = l1[key];
         if (l2)
             ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${val},${l2}`, node);
         ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${val}`, node);

package/lib/Types/Message.d.ts

@@ -112,6 +112,8 @@ export type PollMessageOptions = {
     name: string;
     selectableCount?: number;
     values: string[];
+    /** 32 byte message secret to encrypt poll selections */
+    messageSecret?: Uint8Array;
     toAnnouncementGroup?: boolean;
 };
 export type EventMessageOptions = {

package/lib/Utils/messages.js

@@ -8,6 +8,7 @@ import { proto } from '../WAProto/runtime.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { assertArgumentDomain } from './argument-domain.js';
 import { Boom } from './boom.js';
+import { randomBytes } from 'node:crypto';
 import { sha256 } from './crypto.js';
 import { getKeyAuthor, toNumber, unixTimestampSeconds } from './generics.js';
 import { generateThumbnail, getAudioDuration, getAudioWaveform, getStream, toBuffer } from './messages-media.js';
@@ -434,6 +435,31 @@ export const generateWAMessageContent = async (message, options) => {
         m.eventMessage.extraGuestsAllowed = message.event.extraGuestsAllowed;
         m.eventMessage.isScheduleCall = message.event.isScheduleCall ?? false;
         m.eventMessage.location = message.event.location;
+        // The sender's copy of the key that encrypts responses to this event;
+        // `decryptEventResponse` takes it as `eventEncKey`. WhatsApp Web writes it
+        // on the sender at creation (`WAWebSendEventCreationMsgAction`) and refuses
+        // to build an event edit without it (`WAWebCreateEncryptedEventEditMsgData`
+        // throws `EventCreationValidationError`).
+        //
+        // The core settles `messageSecret` on relay for messages that reach it
+        // without one — see the comment in `Socket/messages.ts` — but it settles it
+        // on the wire, where the caller never sees it. That is right for the
+        // reporting token and wrong for a key the caller has to keep.
+        //
+        // Written after `m.eventMessage`, for the reason spelled out on the poll
+        // branch below: the blocks that attach `contextInfo` take `Object.keys(m)[0]`
+        // as the content key. `event` is not `Mentionable` or `Contextable` today,
+        // so this is ordering that stays correct rather than ordering that is
+        // currently load-bearing — but it costs nothing and the poll branch shows
+        // what getting it wrong looks like.
+        //
+        // Spread rather than upstream's wholesale assignment: nothing else writes
+        // `messageContextInfo` on this branch today, so the two cannot differ, and
+        // this cannot silently drop a field a later change puts there.
+        m.messageContextInfo = {
+            ...m.messageContextInfo,
+            messageSecret: message.event.messageSecret || randomBytes(32)
+        };
     }
     else if (hasNonNullishProperty(message, 'poll')) {
         (_a = message.poll).selectableCount || (_a.selectableCount = 0);
@@ -465,6 +491,29 @@ export const generateWAMessageContent = async (message, options) => {
                 m.pollCreationMessage = pollCreationMessage;
             }
         }
+        // The key that encrypts the votes. `decryptPollVote` takes it as
+        // `pollEncKey`, and without it here the poll goes out fine but its own
+        // sender can never read the votes: the copy they store — the message
+        // `sendMessage` returns and emits as `messages.upsert` — is this object,
+        // and only `key.id` is patched from the relay result. WhatsApp Web writes it
+        // on the sender at creation too (`WAWebPollsSendPollCreationMsgAction`) and
+        // reuses the stored one for poll edits
+        // (`WAWebPollsGeneratePollEditMessageProto`).
+        //
+        // After the payload, not before, and that ordering is load-bearing: the
+        // `mentions` and `contextInfo` blocks below pick their target with
+        // `Object.keys(m)[0]`, so a `messageContextInfo` written first becomes the
+        // content key they attach to. `contextInfo` is not a field of
+        // `IMessageContextInfo`, so the encoder drops it and a poll sent with
+        // mentions loses them silently. `poll` is `Mentionable & Contextable`, so
+        // that is a combination callers can and do write. Upstream assigns it
+        // before the payload and has exactly that bug; measured on
+        // `{poll, mentions:['x@s.whatsapp.net']}`, its output carries no
+        // `mentionedJid` at all.
+        m.messageContextInfo = {
+            ...m.messageContextInfo,
+            messageSecret: message.poll.messageSecret || randomBytes(32)
+        };
     }
     else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
         m.protocolMessage = {
@@ -612,13 +661,54 @@ export const generateWAMessage = async (jid, content, options) => {
         : options;
     return generateWAMessageFromContent(jid, await generateWAMessageContent(content, contentOptions), options);
 };
+/**
+ * The content keys that carry almost every message on a live socket, settled by
+ * identity before the structural predicate runs. Every name here already
+ * satisfies that predicate, so this only shortcuts the substring scan; it never
+ * changes which key wins.
+ */
+const isCommonContentKey = (key) => {
+    switch (key) {
+        case 'conversation':
+        case 'extendedTextMessage':
+        case 'imageMessage':
+        case 'videoMessage':
+        case 'audioMessage':
+        case 'stickerMessage':
+        case 'documentMessage':
+        case 'reactionMessage':
+        case 'protocolMessage':
+        case 'pollCreationMessage':
+            return true;
+        default:
+            return false;
+    }
+};
 /** Get the key to access the true type of content */
 export const getContentType = (content) => {
-    if (content) {
-        const keys = Object.keys(content);
-        const key = keys.find(k => (k === 'conversation' || k.includes('Message')) && k !== 'senderKeyDistributionMessage');
-        return key;
+    if (!content) {
+        return undefined;
+    }
+    // The answer stays positional (the first own key naming content wins), but
+    // the scan is an indexed loop with an early return instead of `Array.find`,
+    // so no closure is allocated and the common keys never reach `includes`.
+    //
+    // Deliberately still `Object.keys` and not `for..in`: a decoded
+    // `WAProto.Message` inherits a default for every field of the schema, so
+    // `for..in` would enumerate ~100 prototype keys per call (and would have to
+    // filter them back out with `hasOwn` to stay positional) where `Object.keys`
+    // yields only the handful that were actually set.
+    const keys = Object.keys(content);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (isCommonContentKey(key)) {
+            return key;
+        }
+        if (key.includes('Message') && key !== 'senderKeyDistributionMessage') {
+            return key;
+        }
     }
+    return undefined;
 };
 const getFutureProofMessage = (message) => message?.ephemeralMessage ||
     message?.viewOnceMessage ||

package/lib/Utils/process-message.js

@@ -24,19 +24,53 @@ export const isRealMessage = (message) => {
         !normalizedContent?.pollUpdateMessage);
 };
 export const shouldIncrementChatUnread = (message) => !message.key.fromMe && !message.messageStubType;
+/**
+ * WhatsApp Web's rules, which upstream Baileys does not always follow.
+ *
+ * **A field with nothing to normalise stays absent.** `WAWebMsgKey` only assigns
+ * the participant it was given — `h !== void 0 && (this.participant = h)` — and
+ * builds the message's identity by joining the parts that are present, so an
+ * empty string there would change what the key serialises to. Upstream runs
+ * every field through `jidNormalizedUser`, which answers `''` for a jid it was
+ * not given, and so writes `participant: ''` onto every direct-message key.
+ * Matching that would mean copying a bug into the key handed back to callers.
+ *
+ * **A hosted jid is re-encoded onto its plain server**, and the fallback that
+ * used to keep `@hosted` when the user part was empty is gone. WA Web accepts
+ * hosted only as `<digits>:99@hosted` (`WAWebWidValidator`), and every jid that
+ * reached the old fallback is one it rejects outright — so there is no
+ * behaviour to preserve there, and agreeing with upstream costs nothing. Valid
+ * hosted jids already agreed.
+ */
 const normalizeMessageJid = (jid) => {
     if (!jid)
         return undefined;
     const hostedPn = isHostedPnUser(jid);
     if (!hostedPn && !isHostedLidUser(jid))
         return jidNormalizedUser(jid);
-    const user = jidDecode(jid)?.user;
-    return user ? jidEncode(user, hostedPn ? 's.whatsapp.net' : 'lid') : jidNormalizedUser(jid);
+    return jidEncode(jidDecode(jid)?.user ?? null, hostedPn ? 's.whatsapp.net' : 'lid');
 };
 /** Normalize device/hosted JIDs and nested reaction/poll keys in place. */
 export const cleanMessage = (message, meId, meLid) => {
-    message.key.remoteJid = normalizeMessageJid(message.key.remoteJid);
-    message.key.participant = normalizeMessageJid(message.key.participant);
+    // Normalise the fields that are there; do not add the ones that are not.
+    //
+    // Writing the result unconditionally put the property on the key even when
+    // there was nothing to normalise, so a direct-message key — which carries no
+    // participant — still gained one holding `undefined`, and `Object.keys` and a
+    // spread saw it. `WAWebMsgKey` assigns the participant it was given and
+    // leaves the key without one otherwise, and that absence is load-bearing
+    // there: it joins the parts that are present into the id the message is
+    // stored under.
+    //
+    // A field the caller did provide is normalised even when it comes back with
+    // nothing, which is the empty string upstream writes — they provided it, so
+    // it is theirs to have normalised, and leaving a `null` in place would only
+    // swap one falsy spelling for another.
+    for (const field of ['remoteJid', 'participant']) {
+        if (!Object.hasOwn(message.key, field) && message.key[field] == null)
+            continue;
+        message.key[field] = normalizeMessageJid(message.key[field]) ?? '';
+    }
     const content = normalizeMessageContent(message.message);
     if (content?.reactionMessage)
         normaliseKey(content.reactionMessage.key);

package/lib/WABinary/jid-utils.js

@@ -57,8 +57,52 @@ export const jidDecode = (jid) => {
         device: device ? +device : undefined
     };
 };
+const CHAR_DEVICE_SEP = 58; // ':'
+const CHAR_AGENT_SEP = 95; // '_'
+/**
+ * Index at which the user component ends, given the index of the '@'.
+ *
+ * `jidDecode` derives the user by splitting the pre-`@` half on ':' and then on
+ * '_', so the user always runs to whichever of ':' or '_' comes first, and to
+ * the '@' when neither is there. Locating that boundary answers both callers
+ * below without the intermediate arrays and result object `jidDecode` allocates.
+ */
+const userEndBefore = (jid, sepIdx) => {
+    for (let i = 0; i < sepIdx; i++) {
+        const code = jid.charCodeAt(i);
+        if (code === CHAR_DEVICE_SEP || code === CHAR_AGENT_SEP) {
+            return i;
+        }
+    }
+    return sepIdx;
+};
+/** As above, or -1 when the JID has no server part: the case `jidDecode` reports as `undefined`. */
+const userEnd = (jid) => {
+    const sepIdx = jid.indexOf('@');
+    return sepIdx < 0 ? -1 : userEndBefore(jid, sepIdx);
+};
 /** Compare the user component of two JIDs, matching upstream Baileys. */
-export const areJidsSameUser = (jid1, jid2) => jidDecode(jid1)?.user === jidDecode(jid2)?.user;
+export const areJidsSameUser = (jid1, jid2) => {
+    // Same answer as comparing `jidDecode(...)?.user`, compared in place: this
+    // runs once per participant check on the message pipeline, and decoding both
+    // sides allocated four arrays and two objects only to throw them away.
+    const end = typeof jid1 === 'string' ? userEnd(jid1) : -1;
+    if (end !== (typeof jid2 === 'string' ? userEnd(jid2) : -1)) {
+        return false;
+    }
+    // Neither side decodes, so upstream compares `undefined === undefined`.
+    if (end < 0) {
+        return true;
+    }
+    const left = jid1;
+    const right = jid2;
+    for (let i = 0; i < end; i++) {
+        if (left.charCodeAt(i) !== right.charCodeAt(i)) {
+            return false;
+        }
+    }
+    return true;
+};
 export const isJidMetaAI = (jid) => jid?.endsWith('@bot');
 export const isPnUser = (jid) => jid?.endsWith('@s.whatsapp.net');
 export const isLidUser = (jid) => jid?.endsWith('@lid');
@@ -71,12 +115,25 @@ export const isHostedPnUser = (jid) => jid?.endsWith('@hosted');
 const botRegexp = /^1313555\d{4}$|^131655500\d{2}$/;
 export const isJidBot = (jid) => jid && botRegexp.test(jid.split('@')[0]) && jid.endsWith('@c.us');
 export const jidNormalizedUser = (jid) => {
-    const result = jidDecode(jid);
-    if (!result) {
+    if (typeof jid !== 'string') {
+        return '';
+    }
+    const sepIdx = jid.indexOf('@');
+    if (sepIdx < 0) {
         return '';
     }
-    const { user, server } = result;
-    return jidEncode(user, server === 'c.us' ? 's.whatsapp.net' : server);
+    // Everything between the user and the '@' is exactly what normalization
+    // drops, so the boundary is all this needs. `jidDecode` would split the same
+    // half twice and box the pieces in an object only for them to be re-joined.
+    const end = userEndBefore(jid, sepIdx);
+    // Fast path for the shape that dominates the pipeline: nothing to strip and a
+    // server `jidEncode` re-emits verbatim, so the JID already is its own normal
+    // form and no new string has to be built at all.
+    if (end === sepIdx && !jid.endsWith('@c.us')) {
+        return jid;
+    }
+    const server = jid.slice(sepIdx + 1);
+    return jidEncode(jid.slice(0, end), server === 'c.us' ? 's.whatsapp.net' : server);
 };
 export const transferDevice = (fromJid, toJid) => {
     const deviceId = jidDecode(fromJid)?.device || 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",
@@ -82,7 +82,7 @@
   },
   "dependencies": {
     "@hapi/boom": "^9.1.4",
-    "@oxidezap/whatsapp-rust-bridge": "0.17.0",
+    "@oxidezap/whatsapp-rust-bridge": "0.18.0",
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5"