whalibmob 5.24.1 → 5.25.0

package/README.md

@@ -2884,7 +2884,7 @@ client.on('version_update', ({ from, to, source }) => {
   console.log('announcing', to, 'instead of', from, '—', source)
 })
 
-await client.init('40756469325')
+await client.init('919634847671')
 ```
 
 **Reconnects are covered too.** The check runs from the socket-connect step
@@ -2923,8 +2923,8 @@ Set `{ refreshVersion: false }` on the client to turn it off.
 The manual tool still works on both platforms:
 
 ```bash
-wa refresh-version 40756469325                    # current build for the platform
-wa refresh-version 40756469325 --version 2.25.1.2 # or one you name
+wa refresh-version 919634847671                    # current build for the platform
+wa refresh-version 919634847671 --version 2.25.1.2 # or one you name
 ```
 
 Companion sessions have never had this problem: `connectWeb()` reads the live
@@ -3575,6 +3575,14 @@ whalibmob implements the full lifecycle to prevent this:
 
 Token storage uses the **LID JID** of the contact (e.g. `112345678901234@lid`) as the key — never the phone-number JID — matching WhatsApp's internal convention.
 
+**cstoken — the companion fallback.** When there is no `<tctoken>` for a recipient, the genuine client attaches a `<cstoken>` instead. Unlike a tctoken it is not granted per contact; it is computed locally:
+
+```
+cstoken = HMAC-SHA256(nctSalt, recipient-LID)
+```
+
+The `nctSalt` is an account-wide secret the server distributes over app state, so only a **companion (QR / pairing-code) session** ever holds one — a primary (SMS) session has none and sends no cstoken, exactly as the real primary does until it has minted its own. When a companion session receives the salt it fires a `nct_salt` event and persists it; from then on, any first DM without a tctoken carries a `<cstoken>` derived for that recipient's LID. Like the rest of this section it is fully automatic — there is nothing to call.
+
 <a id="account-restriction"></a>
 
 ### When 463 Means the Account Is Restricted

package/cli.js

@@ -1385,7 +1385,7 @@ async function handleLine(line) {
         if (!ph) {
           fail('usage: /pair <phone> [8-char-code]');
           out('  the phone number is the account you want to link to, digits only');
-          out('  example: /pair 40756469325');
+          out('  example: /pair 919634847671');
           break;
         }
         if (_client && _client.connected) { fail('already connected — /disconnect first'); break; }
@@ -1402,7 +1402,7 @@ async function handleLine(line) {
           out('  links the number as a companion by QR instead of a pairing code');
           out('  a QR is drawn in the terminal — scan it from the phone that owns');
           out('  the number:  WhatsApp → Linked Devices → Link a device');
-          out('  example: /qrcode 40756469325');
+          out('  example: /qrcode 919634847671');
           break;
         }
         if (_client && _client.connected) { fail('already connected — /disconnect first'); break; }

package/index.d.ts

@@ -688,6 +688,8 @@ export interface WhalibmobEvents {
   /** The server refused the client itself — `405` means the announced version is not accepted. */
   client_rejected: (r: { reason: string; location?: string; message?: string }) => void;
   version_update: (v: { from: string; to: string; source: string }) => void;
+  /** A companion session received the NCT salt (over app state) that cstoken is derived from. */
+  nct_salt: (s: { bytes: number }) => void;
   apk_material_stale: (m: { materialVersion: string; liveVersion: string; hint?: string }) => void;
   number_corrected: (n: { from: string; to: string }) => void;
 

package/lib/BinaryNode.js

@@ -49,7 +49,7 @@ const _JID_SERVERS = new Set([
   's.whatsapp.net', 'g.us', 'lid', 'broadcast', 'call', 'newsletter', 'c.us', 's.us'
 ]);
 
-// "120363427770886227@g.us" / "40756469325:2@s.whatsapp.net" → JID object.
+// "120363427770886227@g.us" / "919634847671:2@s.whatsapp.net" → JID object.
 // Returns null for anything that is not a full JID, so plain strings (and
 // bare server tokens like "g.us", which the dictionary already encodes as a
 // valid address) keep their existing encoding untouched.

package/lib/Client.js

@@ -2229,6 +2229,27 @@ class WhalibmobClient extends EventEmitter {
         case 'delete':
           this.emit('chat_removed', { jid, kind: what.kind, remote: true });
           break;
+        case 'nct_salt_sync': {
+          // The salt the cstoken fallback is derived from. The server
+          // distributes it into app state; a SET carries the bytes, a REMOVE
+          // withdraws it. Kept on the store so it survives a reconnect. Only a
+          // companion ever gets one, which is why cstoken is a companion-only
+          // thing — a primary has no salt on file and sends none, exactly as
+          // the real primary does until it has minted its own.
+          if (removed) {
+            if (this._store) { this._store.nctSalt = null; this._persistStore(); }
+            _whaDbg('[DBG] NCT_SALT cleared');
+          } else {
+            const salt = a.nctSaltSyncAction && a.nctSaltSyncAction.salt;
+            if (salt && salt.length && this._store) {
+              this._store.nctSalt = Buffer.from(salt).toString('base64');
+              this._persistStore();
+              _whaDbg('[DBG] NCT_SALT stored (' + salt.length + ' bytes)');
+              this.emit('nct_salt', { bytes: salt.length });
+            }
+          }
+          break;
+        }
         default:
           // Something the server tracks that this library does not model yet.
           // Reported rather than dropped, so it is visible that it happened.
@@ -2707,6 +2728,67 @@ class WhalibmobClient extends EventEmitter {
     return lid ? lid + device + '@lid' : null;
   }
 
+  // ─── cstoken ────────────────────────────────────────────────────────────────
+  //
+  // The anti-abuse token the genuine client attaches to a message when it has no
+  // trusted-contact token for the recipient. Unlike a tctoken it is not granted
+  // by the server per contact — it is computed locally:
+  //
+  //   cstoken = HMAC-SHA256(nctSalt, recipient LID)
+  //
+  // The salt is account-wide and arrives over app state, so only a companion
+  // ever holds one. A primary (an SMS session) has no salt on file and sends no
+  // cstoken, which is what the real primary does until it has minted its own.
+  //
+  // This mirrors whatsmeow's generateCsToken line for line: a regular user, not
+  // the PSA account and not a bot; the recipient resolved to a LID; the HMAC
+  // taken over that LID's bare `user@lid` string.
+
+  /** The stored NCT salt as bytes, or null when this session has none. */
+  _nctSalt() {
+    const b64 = this._store && this._store.nctSalt;
+    if (!b64) return null;
+    try { const b = Buffer.from(b64, 'base64'); return b.length ? b : null; }
+    catch (_) { return null; }
+  }
+
+  /**
+   * The recipient's bare LID (`user@lid`), or null when there is no mapping.
+   *
+   * A JID already on the LID server is used as-is; a phone JID is resolved
+   * through the same PN→LID map every send uses. Device and agent parts are
+   * dropped — the token is taken over the non-AD address, as whatsmeow does.
+   */
+  _bareLidFor(jid) {
+    if (!jid) return null;
+    const str  = String(jid);
+    const user = str.split('@')[0].split(':')[0];
+    if (!user) return null;
+    if (str.endsWith('@lid')) return user + '@lid';
+    const lid = this._pnToLid && this._pnToLid.get(user);
+    return lid ? lid + '@lid' : null;
+  }
+
+  /**
+   * The cstoken bytes for a recipient, or null when none should be sent.
+   *
+   * Returns null — so no `<cstoken>` is attached — unless a salt is on file,
+   * the recipient is a regular user, and a LID resolves for them. Every one of
+   * those is a reason the genuine client also sends nothing.
+   */
+  _csTokenFor(jid) {
+    const salt = this._nctSalt();
+    if (!salt) return null;
+
+    const { isRegularTcTokenUser } = require('./messages/TcTokenStore');
+    if (!isRegularTcTokenUser(jid)) return null;
+
+    const lidJid = this._bareLidFor(jid);
+    if (!lidJid) return null;
+
+    return crypto.createHmac('sha256', salt).update(lidJid, 'utf8').digest();
+  }
+
   // Every address this message's session might be filed under, best first.
   _signalJidCandidates(from, participant, senderPn) {
     const out = [];

package/lib/SessionPaths.js

@@ -6,17 +6,17 @@
 // the app state, the device cache, the LID maps, the history — used to sit
 // side by side in one directory, named after the number:
 //
-//   ~/.waSession/40756469325.json
-//   ~/.waSession/40756469325.signal.json
-//   ~/.waSession/40756469325.sk.json
+//   ~/.waSession/919634847671.json
+//   ~/.waSession/919634847671.signal.json
+//   ~/.waSession/919634847671.sk.json
 //   ...  × 11 files × every number
 //
 // Fifty numbers made that five hundred files in one place, with no way to move,
 // back up or delete one account without picking its files out of the pile by
 // prefix. A number now gets a directory of its own:
 //
-//   <base>/40756469325/40756469325.json
-//   <base>/40756469325/40756469325.signal.json
+//   <base>/919634847671/919634847671.json
+//   <base>/919634847671/919634847671.signal.json
 //   ...
 //
 // The file names inside are unchanged, so every path built as

package/lib/WebStore.js

@@ -63,7 +63,9 @@ function webStoreToJson(store) {
     platform:    store.platform    || null,
     webVersion:  store.webVersion  || WEB_VERSION_FALLBACK.slice(),
     browser:     store.browser     || WEB_BROWSER.slice(),
-    syncFullHistory: store.syncFullHistory !== false
+    syncFullHistory: store.syncFullHistory !== false,
+    // The NCT salt (base64) a cstoken is derived from, received over app state.
+    nctSalt:     store.nctSalt     || null
   });
 }
 
@@ -87,6 +89,7 @@ function webStoreFromJson(obj) {
   store.webVersion  = obj.webVersion  || WEB_VERSION_FALLBACK.slice();
   store.browser     = obj.browser     || WEB_BROWSER.slice();
   store.syncFullHistory = obj.syncFullHistory !== false;
+  store.nctSalt     = obj.nctSalt     || null;
 
   return store;
 }

package/lib/appstate/Mutations.js

@@ -96,6 +96,8 @@ function describeIndex(index) {
     case 'setting_pushName':return { kind: 'pushName' };
     case 'clearChat':       return { kind: 'clear',    jid };
     case 'deleteChat':      return { kind: 'delete',   jid };
+    // Account-wide, no jid: the salt the cstoken fallback is derived from.
+    case 'nct_salt_sync':   return { kind: 'nct_salt_sync' };
     default:                return { kind, jid };
   }
 }

package/lib/appstate/SyncdProto.js

@@ -125,7 +125,10 @@ const ACTION_FIELDS = {
   17: 'archiveChatAction',
   20: 'markChatAsReadAction',
   21: 'clearChatAction',
-  22: 'deleteChatAction'
+  22: 'deleteChatAction',
+  // NctSaltSyncAction { salt = 1 }. The salt a cstoken is derived from; the
+  // server distributes it into app state and a companion reads it from here.
+  80: 'nctSaltSyncAction'
 };
 
 function decodeSyncActionValue(buf) {
@@ -156,6 +159,8 @@ function decodeSyncActionValue(buf) {
         out.clearChatAction = {}; break;
       case 'deleteChatAction':
         out.deleteChatAction = {}; break;
+      case 'nctSaltSyncAction':
+        out.nctSaltSyncAction = { salt: Buffer.isBuffer(a[1]) ? a[1] : null }; break;
       case 'pushNameSetting':
         out.pushNameSetting = { name: _str(a[1]) }; break;
       case 'contactAction':

package/lib/messages/MessageSender.js

@@ -853,7 +853,7 @@ class MessageSender {
   // ─── Clear all Signal sessions for a phone-number recipient ─────────────────
   //
   // Called on error 479 (stale session).  Deletes:
-  //   • All Signal sessions keyed by phone-number device JIDs (e.g. 40756469325:0)
+  //   • All Signal sessions keyed by phone-number device JIDs (e.g. 919634847671:0)
   //   • The corresponding LID device session if a LID mapping is known
   //
   // Then flushes the device-ID cache for that phone so the next send re-runs
@@ -1119,11 +1119,13 @@ class MessageSender {
       await this._client.ensureTcTokenBeforeSend(tcJid, routingToJid);
     }
 
+    let tcTokenAttached = false;
     if (tcStore) {
       const tcEntry = tcStore.get(tcJid);
       if (tcEntry && tcEntry.token && tcEntry.token.length) {
         if (!tcTokenExpired(tcEntry.timestamp)) {
           msgContent.push(new BinaryNode('tctoken', {}, tcEntry.token));
+          tcTokenAttached = true;
           _whaDbg('[DBG] TCTOKEN_ATTACH jid=' + tcJid);
         } else {
           // Expired token — clear it, keep senderTimestamp for dedupe
@@ -1132,6 +1134,19 @@ class MessageSender {
         }
       }
     }
+
+    // cstoken — the fallback the genuine client attaches when it has no
+    // trusted-contact token. Locally computed HMAC over the recipient's LID; a
+    // companion holds the salt, a primary does not, so this is a no-op on an SMS
+    // session. Never on a protocol message, and never alongside a tctoken —
+    // exactly the `if tctoken … else if cstoken …` the real client does.
+    if (!tcTokenAttached && !isProtocolMsg) {
+      const cs = this._client._csTokenFor(routingToJid);
+      if (cs && cs.length) {
+        msgContent.push(new BinaryNode('cstoken', {}, cs));
+        _whaDbg('[DBG] CSTOKEN_ATTACH jid=' + tcJid);
+      }
+    }
     // ─────────────────────────────────────────────────────────────────────────
 
     // Extra children a caller needs on the stanza — the <meta appdata> a

package/lib/signal/SignalStore.js

@@ -43,9 +43,9 @@ const DEBOUNCE_MS = 300;
 // One-time pre-keys do not live in the snapshot above. They get a file each,
 // named one per id:
 //
-//   <base>/40756469325/40756469325.pre-key-1.json
+//   <base>/919634847671/919634847671.pre-key-1.json
 //   ...
-//   <base>/40756469325/40756469325.pre-key-812.json
+//   <base>/919634847671/919634847671.pre-key-812.json
 //
 // Everything else about a pre-key is small, but there are 812 of them
 // and every one that is consumed rewrites the whole store — so keeping them in
@@ -55,8 +55,8 @@ const DEBOUNCE_MS = 300;
 // authentication folders expects to see, and a write now touches one key.
 //
 // The stem in front of `.pre-key-` is the one the .signal.json file already
-// carries, so a number's mobile half (40756469325.pre-key-N.json) and its
-// companion half (40756469325.web.pre-key-N.json) keep separate pools, as they
+// carries, so a number's mobile half (919634847671.pre-key-N.json) and its
+// companion half (919634847671.web.pre-key-N.json) keep separate pools, as they
 // must — and a session still sitting in the old flat layout, where every
 // number shares one directory, does not collide with its neighbours either.
 //
@@ -224,8 +224,8 @@ class SignalStore {
   attachFile(filePath) {
     this._filePath = filePath;
     // The pre-key files sit beside the snapshot and share its stem, so
-    // 40756469325.signal.json gives 40756469325.pre-key-<id>.json and
-    // 40756469325.web.signal.json gives 40756469325.web.pre-key-<id>.json.
+    // 919634847671.signal.json gives 919634847671.pre-key-<id>.json and
+    // 919634847671.web.signal.json gives 919634847671.web.pre-key-<id>.json.
     const base = path.basename(filePath);
     this._pkDir    = path.dirname(filePath);
     this._pkPrefix = base.endsWith('.signal.json')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.24.1",
+  "version": "5.25.0",
   "description": "Node.js library for WhatsApp — register a number over SMS, or link as a companion by QR. Signal E2E encryption, media, groups, channels.",
   "author": "Kunboruto20",
   "main": "index.js",