whalibmob 5.26.1 → 5.29.0

package/lib/Client.js

@@ -496,12 +496,30 @@ class WhalibmobClient extends EventEmitter {
     // Blue-tick every message as it arrives. Set to false to make read receipts
     // explicit, sent only by a markRead() call.
     this.autoRead = opts.autoRead !== false;
+
+    // Every incoming call is refused unless this is turned off. Off does not
+    // mean calls are answered — nothing here can answer one — it means the
+    // refusal is left to the caller, which is the only way to let some calls
+    // ring and reject the rest. See rejectCall().
+    this._autoRejectCalls = opts.autoRejectCalls !== false;
     // Flipped by setOnline(). Delivery receipts sent while this is false carry
     // type="inactive", which the sender's app records but does not render.
     this._sendActiveReceipts = false;
     // Cached privacy settings. Warmed after connect and refreshed whenever the
     // server reports a change; markRead reads it.
     this._privacySettings = null;
+    // The account's AB props, and the hash that turns the next sync into a
+    // delta. Both live for the session: a fresh process asks for the full set,
+    // which is what a fresh install does.
+    this._abProps     = null;
+    this._abPropsHash = null;
+    // Whether to sync AB props on connect. On by default because the app does
+    // it on every login and a client that never does is running on guessed
+    // defaults, but it is one IQ a caller may not want on a short session.
+    this._syncAbPropsOnConnect = opts.syncAbPropsOnConnect !== false;
+    // noticeId → accepted. Absent means this session has not asked, which
+    // isTosAccepted reports as null rather than as "not accepted".
+    this._tosAccepted = new Map();
     if (opts.pino !== undefined) _whaConfigLogger(opts.pino);
   }
 
@@ -1696,6 +1714,16 @@ class WhalibmobClient extends EventEmitter {
     this.queryPrivacySettings({ force: true }).catch(err =>
       _whaDbg('[DBG] PRIVACY_FETCH_FAILED ' + (err && err.message)));
 
+    // Sync the account's AB props, as the app does on every login. On a
+    // reconnect the stored hash makes this a delta rather than the whole
+    // table. A failure is logged and nothing else: every reader of these has a
+    // default to fall back on, so a client that could not fetch them still
+    // works — it just works on the defaults.
+    if (this._syncAbPropsOnConnect) {
+      this.queryAbProps({ force: true }).catch(err =>
+        _whaDbg('[DBG] AB_PROPS_FETCH_FAILED ' + (err && err.message)));
+    }
+
     // ── Reconnect: flush stale device cache + background re-usync ─────────────
     // On first connect _hasConnectedOnce is false — nothing extra to do.
     // On every reconnect (network drop / NAT reset / server restart) we flush the
@@ -3815,6 +3843,11 @@ class WhalibmobClient extends EventEmitter {
       // so a change made on the phone never reached the cache.
       const privacyNode = findChildDeep(node, 'privacy');
       if (privacyNode) this._handlePrivacySettingsNotification(privacyNode);
+      // ...and Terms-of-Service acceptances. Accepting a notice on the phone
+      // arrives here, and it is the only way this side learns about it without
+      // asking.
+      const tosNode = findChildDeep(node, 'tos');
+      if (tosNode) this._handleTosNotification(tosNode);
     }
 
     if (type === 'w:gp2') {
@@ -4162,20 +4195,46 @@ class WhalibmobClient extends EventEmitter {
       }
     }
 
-    this.emit('call', { from: attrs.from || '', node });
-    // Reject call automatically
-    if (this._socket && this._connected) {
-      const offer = findChild(node, 'offer');
-      const callId = offer && offer.attrs && offer.attrs.call_id;
-      if (callId) {
-        this._socket.sendNode(new BinaryNode('call', {
-          to: attrs.from || '',
-          id: this._genMsgId()
-        }, [new BinaryNode('reject', { call_id: callId, call_creator: attrs.from || '' }, null)]));
-      }
+    // What the stanza actually says, rather than the raw node alone: which call
+    // it is, and what stage it is at. A caller deciding whether to reject needs
+    // both, and digging them out of the node is not its job.
+    const offer  = findChild(node, 'offer');
+    const relay  = findChild(node, 'relaylatency');
+    const term   = findChild(node, 'terminate');
+    const callId = (offer && offer.attrs && offer.attrs.call_id) ||
+                   (term  && term.attrs  && term.attrs.call_id)  || null;
+    const status = offer ? 'offer' : (term ? 'terminate' : (relay ? 'ringing' : 'unknown'));
+
+    this.emit('call', { from: attrs.from || '', id: callId, status, node });
+
+    // Reject every incoming call, unless the caller asked to decide for itself.
+    // Turning this off does not answer calls — nothing here can — it only stops
+    // the automatic refusal, so a caller can reject some and let the rest ring.
+    if (this._autoRejectCalls && callId && status === 'offer') {
+      this.rejectCall(callId, attrs.from || '');
     }
   }
 
+  /**
+   * Refuse one incoming call.
+   *
+   * Only needed when the client was built with `autoRejectCalls: false`; with
+   * the default every call is refused before this could be reached. The call id
+   * and the caller both come off the `call` event.
+   *
+   * @param {string} callId  the `id` from the call event
+   * @param {string} from    the `from` from the call event
+   * @returns {boolean} whether the refusal could be sent
+   */
+  rejectCall(callId, from) {
+    if (!callId || !this._socket || !this._connected) return false;
+    this._socket.sendNode(new BinaryNode('call', {
+      to: from || '',
+      id: this._genMsgId()
+    }, [new BinaryNode('reject', { call_id: callId, call_creator: from || '' }, null)]));
+    return true;
+  }
+
   // ─── Auth failure (server forces logout during active session) ──────────────
 
   // <failure> ends the connection, but not every reason means the session died.
@@ -6495,6 +6554,467 @@ class WhalibmobClient extends EventEmitter {
     return this._sender.deleteMessage(origMsgId, chatJid, fromMe, forEveryone, opts);
   }
 
+  // ─── AB props — the server's own feature flags ────────────────────────────
+  //
+  // Every WhatsApp client asks the server which experiments and configuration
+  // values apply to this account and then gates behaviour on the answer: how
+  // many bytes an identity hash is truncated to, whether the LID migration has
+  // started here, what sampling weight each telemetry event carries. A client
+  // that never asks runs on guessed defaults wherever the server has an
+  // opinion — and never asking is itself unlike the app, which asks on every
+  // login.
+  //
+  //   <iq xmlns="abt" to="s.whatsapp.net" type="get">
+  //     <props protocol="1" [hash="..."] [refresh_id="..."]/>
+  //   </iq>
+  //
+  // The reply carries a hash of the set it returned. Sending that hash back on
+  // the next request asks for a delta rather than the whole table, which is
+  // what the app does once it has synced. The hash is kept for the session
+  // only — a fresh process asks for the full set, exactly as a fresh install
+  // does — so nothing here has to be persisted or migrated.
+  //
+  // Values come back as strings because that is what the wire carries. Typing
+  // them per prop would need a table this side does not have, and guessing
+  // would be wrong more often than it is useful; `abPropInt` and `abPropBool`
+  // are there for the two readings that are worth having.
+
+  /**
+   * Sync this account's AB props.
+   *
+   * Served from the session cache unless `force` is set. A reply the server
+   * marks `delta_update` is merged onto what is already held rather than
+   * replacing it, which is the whole point of sending the hash.
+   *
+   * @param   {object}  [opts]
+   * @param   {boolean} [opts.force]      re-ask even when a set is cached
+   * @param   {string}  [opts.refreshId]  the emergency-push branch. The server
+   *          announces a refresh id when a global update has to propagate at
+   *          once; sending it takes the place of the hash.
+   * @returns {Promise<{hash: string|null, abKey: string|null,
+   *                    refresh: number|null, refreshId: string|null,
+   *                    delta: boolean, props: Object<string,string>,
+   *                    sampling: Object<string,number>}>}
+   */
+  async queryAbProps(opts) {
+    opts = opts || {};
+    if (this._abProps && !opts.force && opts.refreshId == null) return this._abProps;
+
+    const propsAttrs = { protocol: '1' };
+    // One or the other, never both: a refresh id names a specific update to
+    // fetch, and a hash asks for whatever has changed since it. Sending both
+    // asks two different questions in one stanza.
+    if (opts.refreshId != null) propsAttrs.refresh_id = String(opts.refreshId);
+    else if (this._abPropsHash)  propsAttrs.hash       = this._abPropsHash;
+
+    const resp = await this._sendIq(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'get',
+      xmlns: 'abt'
+    }, [new BinaryNode('props', propsAttrs, null)]));
+
+    if (!resp) throw new Error('queryAbProps: no reply from server (IQ timed out)');
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      throw new Error('queryAbProps: server rejected the request' +
+        (code ? ' (' + code + ')' : ''));
+    }
+
+    const parsed = this._parseAbProps(findChild(resp, 'props'));
+
+    // A delta names only what moved. Replacing the cache with it would drop
+    // every prop the server saw no reason to repeat.
+    if (parsed.delta && this._abProps) {
+      parsed.props    = Object.assign({}, this._abProps.props,    parsed.props);
+      parsed.sampling = Object.assign({}, this._abProps.sampling, parsed.sampling);
+    }
+
+    if (parsed.hash) this._abPropsHash = parsed.hash;
+    this._abProps = parsed;
+    _whaDbg('[DBG] AB_PROPS ' + (parsed.delta ? 'delta' : 'full') +
+      ' props=' + Object.keys(parsed.props).length +
+      ' sampling=' + Object.keys(parsed.sampling).length +
+      (parsed.hash ? ' hash=' + parsed.hash : ''));
+    return parsed;
+  }
+
+  // <props hash ab_key refresh refresh_id delta_update>
+  //   <prop config_code="..." config_value="..."/>     an experiment value
+  //   <prop event_code="..."  sampling_weight="..."/>  a telemetry weight
+  // </props>
+  //
+  // The two shapes share a tag and are told apart by which attributes they
+  // carry, so each child is tried as an experiment first and as a sampling
+  // entry second. A child that is neither is skipped rather than allowed to
+  // fail the whole sync — an unknown shape is a prop this version has not
+  // learned about, not a broken reply.
+  _parseAbProps(propsNode) {
+    const out = {
+      hash:      null,
+      abKey:     null,
+      refresh:   null,
+      refreshId: null,
+      delta:     false,
+      props:     {},
+      sampling:  {}
+    };
+    if (!propsNode || !propsNode.attrs) return out;
+
+    const a = propsNode.attrs;
+    out.hash      = a.hash       ? String(a.hash)       : null;
+    out.abKey     = a.ab_key     ? String(a.ab_key)     : null;
+    out.refreshId = a.refresh_id ? String(a.refresh_id) : null;
+
+    const refresh = Number(a.refresh);
+    if (Number.isFinite(refresh) && refresh > 0) out.refresh = refresh;
+
+    // The server writes this as a string, and "false" is a true string.
+    out.delta = a.delta_update === 'true' || a.delta_update === true || a.delta_update === '1';
+
+    const children = Array.isArray(propsNode.content) ? propsNode.content : [];
+    for (const child of children) {
+      if (!child || child.description !== 'prop' || !child.attrs) continue;
+      const c = child.attrs;
+
+      if (c.config_code != null && c.config_value != null) {
+        out.props[String(c.config_code)] = String(c.config_value);
+        continue;
+      }
+
+      if (c.event_code != null && c.sampling_weight != null) {
+        const code   = Number(c.event_code);
+        const weight = Number(c.sampling_weight);
+        // Bounds the app itself applies. A code below 1 names no event, and a
+        // weight outside the range is not a weight — both mean this entry was
+        // misread rather than that the server sent something exotic.
+        if (Number.isFinite(code) && code >= 1 &&
+            Number.isFinite(weight) && weight >= 0 && weight <= 1000000) {
+          out.sampling[String(code)] = weight;
+        }
+      }
+    }
+    return out;
+  }
+
+  /**
+   * One AB prop as a string, or `fallback` when the server has not set it.
+   *
+   * Props are addressed by their numeric code, which is what the wire uses.
+   * Reading one before `queryAbProps` has run returns the fallback rather than
+   * throwing: a caller gating on a flag wants the default, not an exception.
+   *
+   * @param   {number|string} code
+   * @param   {string|null}   [fallback=null]
+   * @returns {string|null}
+   */
+  abProp(code, fallback) {
+    const value = this._abProps && this._abProps.props[String(code)];
+    return value === undefined || value === null ? (fallback === undefined ? null : fallback) : value;
+  }
+
+  /** The same, read as an integer. Anything unparseable gives the fallback. */
+  abPropInt(code, fallback) {
+    const raw = this.abProp(code, null);
+    const n   = Number(raw);
+    return raw === null || !Number.isFinite(n) ? (fallback === undefined ? null : fallback) : n;
+  }
+
+  /**
+   * The same, read as a flag.
+   *
+   * The wire spells these as "1"/"0" and as "true"/"false" depending on the
+   * prop, so both are understood; anything else gives the fallback rather than
+   * being coerced, since a prop carrying a version string is not a flag.
+   */
+  abPropBool(code, fallback) {
+    const raw = this.abProp(code, null);
+    if (raw === '1' || raw === 'true')  return true;
+    if (raw === '0' || raw === 'false') return false;
+    return fallback === undefined ? null : fallback;
+  }
+
+  // ─── Contact sync — telling the server which numbers are in the book ──────
+  //
+  // The app uploads its address book on first launch and re-syncs deltas
+  // afterwards, which is how it learns who is reachable and how the server
+  // learns who this account knows. whalibmob has had the whole usync machinery
+  // for device discovery all along and never used it for this, so an account
+  // could send to a hundred strangers having never synced a single contact —
+  // a shape nothing on a phone produces.
+  //
+  // This is the same <iq xmlns="usync"> the device path builds, with the
+  // contact protocol on its own and the mode and context that name an address
+  // book upload rather than a lookup.
+
+  /**
+   * Sync contacts, and learn which of them are on WhatsApp.
+   *
+   * @param   {string[]} phones  E.164 numbers. A leading `+` is added when
+   *          missing, since that is the only form the contact protocol takes.
+   * @param   {object}   [opts]
+   * @param   {'full'|'delta'|'query'} [opts.mode]  `full` — the whole book, what
+   *          the app sends on first launch; `delta` — what changed since;
+   *          `query` — a lookup that claims nothing about the book. Defaults to
+   *          `full`.
+   * @param   {string}   [opts.context]  defaults to `registration` for a full
+   *          sync (the app's own first-launch context) and `interactive`
+   *          otherwise.
+   * @param   {number}   [opts.chunkSize=500]  numbers per IQ.
+   * @returns {Promise<{registered: string[], unregistered: string[],
+   *                    jids: Object<string,string>}>}
+   *          `registered` and `unregistered` hold the numbers as passed in;
+   *          `jids` maps each registered number to the JID the server gave it.
+   */
+  async syncContacts(phones, opts) {
+    if (!this._connected) throw new Error('Not connected');
+    // _devMgr is torn down on close and rebuilt on init. Saying so beats the
+    // null dereference a caller would otherwise get from a session that is
+    // connected but has been through a teardown.
+    if (!this._devMgr) throw new Error('syncContacts: no device manager — the session is not initialised');
+    if (!Array.isArray(phones)) throw new Error('syncContacts: phones must be an array');
+
+    opts = opts || {};
+    const mode      = opts.mode || 'full';
+    const context   = opts.context || (mode === 'full' ? 'registration' : 'interactive');
+    const chunkSize = Number(opts.chunkSize) > 0 ? Number(opts.chunkSize) : 500;
+
+    const { USyncQuery, USyncUser } = require('./WAUSync');
+
+    // Normalise once, and keep the caller's spelling to answer in. Duplicates
+    // are dropped here rather than sent: the server counts what it is asked
+    // about, and asking twice about one number in one book is not what a
+    // phone does.
+    const wanted = [];
+    const seen   = new Set();
+    for (const raw of phones) {
+      const digits = String(raw || '').replace(/[^\d]/g, '');
+      if (!digits || seen.has(digits)) continue;
+      seen.add(digits);
+      wanted.push({ input: String(raw), digits });
+    }
+
+    const out = { registered: [], unregistered: [], jids: {} };
+    if (wanted.length === 0) return out;
+
+    for (let i = 0; i < wanted.length; i += chunkSize) {
+      const chunk = wanted.slice(i, i + chunkSize);
+
+      const query = new USyncQuery()
+        .withMode(mode)
+        .withContext(context)
+        .withContactProtocol();
+      for (const c of chunk) query.withUser(new USyncUser().withPhone('+' + c.digits));
+
+      const parsed = await this._devMgr.executeUSyncQuery(query);
+
+      // A chunk the server did not answer leaves its numbers unclassified
+      // rather than marked absent. Reporting "not on WhatsApp" for a timeout
+      // is the one wrong answer here — a caller acts on it.
+      if (!parsed || !Array.isArray(parsed.list)) {
+        _whaDbg('[DBG] CONTACT_SYNC chunk ' + (i / chunkSize) + ' unanswered — ' +
+          chunk.length + ' numbers left unclassified');
+        continue;
+      }
+
+      // The reply is keyed by JID, so match each entry back to the number it
+      // came from by the JID's user part.
+      const byUser = new Map();
+      for (const entry of parsed.list) {
+        if (!entry || !entry.id) continue;
+        const user = String(entry.id).split('@')[0].split(':')[0];
+        byUser.set(user, entry);
+      }
+
+      for (const c of chunk) {
+        const entry = byUser.get(c.digits);
+        if (!entry) continue;                    // unclassified, as above
+        if (entry.contact === true) {
+          out.registered.push(c.input);
+          out.jids[c.input] = String(entry.id);
+        } else {
+          out.unregistered.push(c.input);
+        }
+      }
+    }
+
+    _whaDbg('[DBG] CONTACT_SYNC mode=' + mode + ' context=' + context +
+      ' asked=' + wanted.length + ' on=' + out.registered.length +
+      ' off=' + out.unregistered.length);
+    return out;
+  }
+
+  // ─── Terms-of-Service notices ─────────────────────────────────────────────
+  //
+  // WhatsApp gates some surfaces on the account having accepted a given legal
+  // notice — a Terms update, a privacy-policy change, a regional disclosure.
+  // The app pulls the acceptance state, shows the ones that are outstanding,
+  // and posts back what the user accepted.
+  //
+  //   read    <iq xmlns="tos" type="get"><request><notice id="..."/></request></iq>
+  //   accept  <iq xmlns="tos" type="set"><request type="session_update">
+  //             <notice id="..."/></request></iq>
+  //   clear   <iq xmlns="tos" type="set"><delete id="..."/></iq>
+  //
+  // The reply's `state` attribute reads backwards from how it looks: it is
+  // present and "false" for a notice that has NOT been accepted, and absent
+  // for one that has. Treating a missing attribute as "unknown" would report
+  // every accepted notice as outstanding.
+
+  /**
+   * Read the acceptance state of one or more notices.
+   *
+   * @param   {string[]} noticeIds
+   * @returns {Promise<{refresh: number|null,
+   *                    notices: Array<{id: string, accepted: boolean}>}>}
+   *          `refresh` is how many seconds the server suggests waiting before
+   *          asking again.
+   */
+  async queryTosNotices(noticeIds) {
+    if (!this._connected) throw new Error('Not connected');
+    if (!Array.isArray(noticeIds)) throw new Error('queryTosNotices: noticeIds must be an array');
+
+    const ids = noticeIds.map(id => String(id)).filter(Boolean);
+    const resp = await this._sendIq(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'get',
+      xmlns: 'tos'
+    }, [new BinaryNode('request', {},
+      ids.map(id => new BinaryNode('notice', { id }, null)))]));
+
+    if (!resp) throw new Error('queryTosNotices: no reply from server (IQ timed out)');
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      throw new Error('queryTosNotices: server rejected the request' +
+        (code ? ' (' + code + ')' : ''));
+    }
+
+    const parsed = this._parseTosNotices(findChild(resp, 'tos'));
+    for (const n of parsed.notices) this._tosAccepted.set(n.id, n.accepted);
+    _whaDbg('[DBG] TOS_QUERY asked=' + ids.length + ' answered=' + parsed.notices.length +
+      ' outstanding=' + parsed.notices.filter(n => !n.accepted).length);
+    return parsed;
+  }
+
+  // <tos refresh="86400"><notice id="..." [state="false"]/>...</tos>
+  _parseTosNotices(tosNode) {
+    const out = { refresh: null, notices: [] };
+    if (!tosNode) return out;
+
+    const refresh = Number(tosNode.attrs && tosNode.attrs.refresh);
+    if (Number.isFinite(refresh) && refresh > 0) out.refresh = refresh;
+
+    const children = Array.isArray(tosNode.content) ? tosNode.content : [];
+    for (const child of children) {
+      if (!child || child.description !== 'notice' || !child.attrs || !child.attrs.id) continue;
+      const state = child.attrs.state;
+      // Only an explicit "false" means not accepted; see the note above.
+      out.notices.push({
+        id:       String(child.attrs.id),
+        accepted: !(state === 'false' || state === false)
+      });
+    }
+    return out;
+  }
+
+  /**
+   * Accept one or more notices.
+   *
+   * @param   {string[]} noticeIds
+   * @returns {Promise<{ok: true, raw: any}>}
+   */
+  async acceptTosNotices(noticeIds) {
+    if (!this._connected) throw new Error('Not connected');
+    if (!Array.isArray(noticeIds) || noticeIds.length === 0) {
+      throw new Error('acceptTosNotices: noticeIds must be a non-empty array');
+    }
+
+    const ids = noticeIds.map(id => String(id)).filter(Boolean);
+    const resp = await this._sendIq(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'set',
+      xmlns: 'tos'
+    }, [new BinaryNode('request', { type: 'session_update' },
+      ids.map(id => new BinaryNode('notice', { id }, null)))]));
+
+    if (!resp) throw new Error('acceptTosNotices: no reply from server (IQ timed out)');
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      throw new Error('acceptTosNotices: server rejected the request' +
+        (code ? ' (' + code + ')' : ''));
+    }
+
+    for (const id of ids) this._tosAccepted.set(id, true);
+    _whaDbg('[DBG] TOS_ACCEPT ' + ids.join(','));
+    return { ok: true, raw: resp };
+  }
+
+  /**
+   * Clear the accepted state of one notice, so the server asks for it again.
+   *
+   * @param   {string} noticeId
+   * @returns {Promise<{ok: true, raw: any}>}
+   */
+  async clearTosNotice(noticeId) {
+    if (!this._connected) throw new Error('Not connected');
+    const id = String(noticeId || '');
+    if (!id) throw new Error('clearTosNotice: noticeId is required');
+
+    const resp = await this._sendIq(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'set',
+      xmlns: 'tos'
+    }, [new BinaryNode('delete', { id }, null)]));
+
+    if (!resp) throw new Error('clearTosNotice: no reply from server (IQ timed out)');
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      throw new Error('clearTosNotice: server rejected the request' +
+        (code ? ' (' + code + ')' : ''));
+    }
+
+    this._tosAccepted.set(id, false);
+    _whaDbg('[DBG] TOS_CLEAR ' + id);
+    return { ok: true, raw: resp };
+  }
+
+  /**
+   * Whether a notice is known to have been accepted.
+   *
+   * `null` means this session has not asked about it — which is not the same
+   * as "not accepted", and a caller deciding whether to prompt needs to be
+   * able to tell those apart.
+   *
+   * @param   {string} noticeId
+   * @returns {boolean|null}
+   */
+  isTosAccepted(noticeId) {
+    const known = this._tosAccepted.get(String(noticeId));
+    return known === undefined ? null : known;
+  }
+
+  // The server pushing a notice's state at us, rather than us asking:
+  // <notification type="account_sync"><tos><notice id=".." state=".."/></tos>
+  //
+  // This is how an acceptance made on another device reaches this one. It only
+  // ever adds to what is known — a push naming three notices says nothing
+  // about a fourth.
+  _handleTosNotification(tosNode) {
+    const parsed = this._parseTosNotices(tosNode);
+    if (parsed.notices.length === 0) return;
+    for (const n of parsed.notices) this._tosAccepted.set(n.id, n.accepted);
+    _whaDbg('[DBG] TOS_NOTIFICATION ' + parsed.notices
+      .map(n => n.id + '=' + (n.accepted ? 'accepted' : 'outstanding')).join(' '));
+    this.emit('tos_notices', { notices: parsed.notices });
+  }
+
   // ─── Status / Stories ─────────────────────────────────────────────────────
 
   // Who your Status posts go to.

package/lib/CompanionPairing.js

@@ -18,7 +18,7 @@
 // from that account.
 
 const crypto  = require('crypto');
-const curveJs = require('curve25519-js');
+const curveJs = require('./curve');
 
 const WA_ADV_ACCOUNT_SIG_PREFIX        = Buffer.from([6, 0]);
 const WA_ADV_DEVICE_SIG_PREFIX         = Buffer.from([6, 1]);

package/lib/HistorySyncHandler.js

@@ -26,13 +26,13 @@
  */
 
 const crypto = require('crypto');
+const { hkdfSha256 } = require('./hkdf');
 const https  = require('https');
 const http   = require('http');
 const zlib   = require('zlib');
 const fs     = require('fs');
 const path   = require('path');
 
-const { hkdf }   = require('@noble/hashes/hkdf');
 const { sha256 } = require('@noble/hashes/sha256');
 
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -442,7 +442,7 @@ function decodeHistorySync(buf) {
 function deriveHistoryKeys(mediaKeyBuf) {
   const ikm  = Buffer.isBuffer(mediaKeyBuf) ? mediaKeyBuf : Buffer.from(mediaKeyBuf);
   const info = Buffer.from(HISTORY_HKDF_INFO, 'utf8');
-  const expanded = Buffer.from(hkdf(sha256, ikm, Buffer.alloc(0), info, EXPANDED_SIZE));
+  const expanded = hkdfSha256(ikm, Buffer.alloc(0), info, EXPANDED_SIZE);
   return {
     iv:        expanded.slice(0, IV_LEN),
     cipherKey: expanded.slice(IV_LEN, IV_LEN + KEY_LEN),

package/lib/MediaService.js

@@ -1,11 +1,11 @@
 'use strict';
 
 const crypto  = require('crypto');
+const { hkdfSha256 } = require('./hkdf');
 const https   = require('https');
 const http    = require('http');
 const fs      = require('fs');
 const path    = require('path');
-const { hkdf } = require('@noble/hashes/hkdf');
 const { sha256 } = require('@noble/hashes/sha256');
 const { getDeviceConfig } = require('./DeviceConfig');
 
@@ -69,7 +69,7 @@ const MAC_LEN       = 10;
 function deriveMediaKeyData(mediaKey, keyName) {
   const ikm  = Buffer.isBuffer(mediaKey) ? mediaKey : Buffer.from(mediaKey);
   const info = Buffer.from(keyName, 'utf8');
-  return Buffer.from(hkdf(sha256, ikm, Buffer.alloc(0), info, EXPANDED_SIZE));
+  return hkdfSha256(ikm, Buffer.alloc(0), info, EXPANDED_SIZE);
 }
 
 function encryptMedia(plaintext, mediaKey, keyName) {

package/lib/PairingCode.js

@@ -25,7 +25,8 @@
 // in normally.
 
 const crypto = require('crypto');
-const curveJs = require('curve25519-js');
+const { hkdfSha256 } = require('./hkdf');
+const curveJs = require('./curve');
 
 // Crockford base32 minus the ambiguous characters — no I, O, U, and no 0.
 // Five random bytes become exactly eight characters.
@@ -85,15 +86,12 @@ function aesEncryptGCM(plaintext, key, iv, aad) {
 }
 
 function hkdf(input, length, info, salt) {
-  const { hkdf: nobleHkdf } = require('@noble/hashes/hkdf');
-  const { sha256 } = require('@noble/hashes/sha256');
-  return Buffer.from(nobleHkdf(
-    sha256,
+  return hkdfSha256(
     input,
     salt || Buffer.alloc(32),
     info ? Buffer.from(info, 'utf8') : Buffer.alloc(0),
     length
-  ));
+  );
 }
 
 function stripKeyPrefix(pub) {