whalibmob 5.5.21 → 5.5.23

package/README.md

@@ -6,6 +6,20 @@
 > [!CAUTION]
 > Use a dedicated phone number with this library. Connecting with a number that is already active on a real device will cause WhatsApp to log that device out.
 
+> [!CAUTION] 
+> Whalibmob now It needs to be rewritten because WhatsApp mobile and has changed the protocol lately and now whalibmob is in testing and some updates by Me Any pull request is accepted. 
+
+
+> [!IMPORTANT] 
+> If you like what I do and want to support me I can leave you here my Crypto usdc address for any donation and support any Small donation is accepted because the WhatsApp protocol changes very often : "0x8AD64F47a715eC24DeF193FBb9aC64d4E857f0f3"
+ 
+Usdc ethereum network.
+
+
+
+
+
+
 > [!IMPORTANT]
 > This project is not affiliated, associated, authorized, endorsed by, or in any way officially connected with WhatsApp or any of its subsidiaries or affiliates. "WhatsApp" and related names are registered trademarks of their respective owners. Use at your own discretion.
 
@@ -102,6 +116,11 @@ npm install -g whalibmob
     - [Register a New Number](#register-a-new-number)
     - [Connect](#connect)
   - [Saving & Restoring Sessions](#saving--restoring-sessions)
+  - [Signal Store Utilities](#signal-store-utilities)
+    - [makeCacheableSignalKeyStore](#makecacheablesignalkeystore)
+    - [addTransactionCapability](#addtransactioncapability)
+    - [assertMeId](#assertmeid)
+    - [initAuthCreds](#initauthcreds)
   - [Handling Events](#handling-events)
     - [Example to Start](#example-to-start)
     - [All Events](#all-events)
@@ -267,6 +286,138 @@ await client.init('919634847671')
 > [!NOTE]
 > Each phone number uses its own session file. The library handles Signal Protocol key persistence automatically.
 
+## Signal Store Utilities
+
+`auth-utils` is a collection of optional helpers for power users who manage their own `SignalStore` instances directly (e.g. custom storage backends, multi-account servers).
+
+```js
+const {
+  makeCacheableSignalKeyStore,
+  addTransactionCapability,
+  assertMeId,
+  initAuthCreds
+} = require('whalibmob')
+```
+
+### `makeCacheableSignalKeyStore`
+
+Wraps a `SignalStore` with an in-memory NodeCache layer (5-minute TTL). All `get` calls for `sessions`, `preKeys`, `signedPreKeys`, and `identities` are served from cache on subsequent accesses. Writes invalidate the cache automatically.
+
+`useClones` is set to `false` so that `SessionRecord` objects — which carry internal state and methods — are returned by reference and never deep-cloned.
+
+The wrapper also forwards `transaction()` and `isInTransaction()` calls to the underlying store when present, making it safe to stack with `addTransactionCapability`.
+
+```js
+const { SignalStore } = require('whalibmob')
+const { makeCacheableSignalKeyStore } = require('whalibmob')
+
+const store  = new SignalStore(/* ... */)
+const cached = makeCacheableSignalKeyStore(store)
+
+// reads hit cache after first access
+const session = await cached.getSession('919634847671@s.whatsapp.net:0')
+```
+
+**When to use:** whenever your `SignalStore` is backed by a remote or disk-based store (database, Redis, file system) and you want to reduce repeated lookups for sessions that haven't changed between sends.
+
+### `addTransactionCapability`
+
+Wraps a `SignalStore` with batched-write (transaction) semantics. During a transaction all writes are buffered in memory; they are flushed to the underlying store atomically when `commit()` is called at the end of the transaction.
+
+Uses `AsyncLocalStorage` to propagate transaction context across async call chains, and a per-key-type `Mutex` with reference-counting to serialize concurrent writers safely.
+
+```js
+const { addTransactionCapability, makeCacheableSignalKeyStore } = require('whalibmob')
+
+// recommended: cache first, then transactions on top
+const base        = new SignalStore(/* ... */)
+const cached      = makeCacheableSignalKeyStore(base)
+const txnStore    = addTransactionCapability(cached)
+
+// inside a send flow
+await txnStore.transaction(async () => {
+  // all writes are buffered
+  await txnStore.setSession('919634847671@s.whatsapp.net:0', sessionRecord)
+  await txnStore.setPreKey(1, preKeyPair)
+  // commit is called automatically at the end of the transaction callback
+})
+```
+
+Stacking order matters: put `makeCacheableSignalKeyStore` below `addTransactionCapability` so that the cache always sees the committed state.
+
+**When to use:** for high-throughput servers that send to many recipients concurrently and need to batch Signal key writes into a single atomic flush per message.
+
+### `assertMeId`
+
+Validates that a store object has a registered phone number and returns the canonical `@s.whatsapp.net` JID. Throws an `Error` if the store lacks a `phoneNumber` or has `registered !== true`.
+
+```js
+const { assertMeId } = require('whalibmob')
+
+const store = loadStore(sessFile)
+
+try {
+  const jid = assertMeId(store)
+  // jid === '919634847671@s.whatsapp.net'
+  console.log('account JID:', jid)
+} catch (err) {
+  console.error('store is not registered:', err.message)
+}
+```
+
+**When to use:** as a guard before calling `client.init()` to give a clear error message when a corrupted or unregistered session file is accidentally loaded.
+
+### `initAuthCreds`
+
+Creates a fresh credential store for the given phone number. Functionally equivalent to `createNewStore` but also initialises the Baileys-compatible extra fields that the library expects for account sync: `nextPreKeyId`, `firstUnuploadedPreKeyId`, `accountSyncCounter`, `accountSettings`, and `advSecretKey`.
+
+```js
+const { initAuthCreds, saveStore } = require('whalibmob')
+const path = require('path')
+const fs   = require('fs')
+
+const phone    = '919634847671'
+const sessDir  = path.join(process.env.HOME, '.waSession')
+const sessFile = path.join(sessDir, phone + '.json')
+
+fs.mkdirSync(sessDir, { recursive: true })
+
+const store = initAuthCreds(phone)
+saveStore(store, sessFile)
+```
+
+This is the function used internally by the CLI for all new session creation. Prefer it over `createNewStore` for forward compatibility.
+
+> [!NOTE]
+> `initAuthCreds` and `createNewStore` produce equivalent stores for all current library operations. The additional fields from `initAuthCreds` are there for future-proofing and interoperability.
+
+### Recommended Stacking Pattern
+
+For a production multi-account server:
+
+```js
+const {
+  SignalStore,
+  makeCacheableSignalKeyStore,
+  addTransactionCapability,
+  initAuthCreds,
+  saveStore,
+  loadStore
+} = require('whalibmob')
+
+// 1. load or create the credential store
+let store = loadStore(sessFile) || initAuthCreds(phone)
+
+// 2. build the layered Signal key store
+const signalStore = new SignalStore(store)
+const cachedStore = makeCacheableSignalKeyStore(signalStore)
+const txnStore    = addTransactionCapability(cachedStore)
+
+// 3. pass to the client (advanced usage — most users should use WhalibmobClient directly)
+```
+
+For standard usage, `WhalibmobClient` handles all of this internally. These helpers are for advanced scenarios where you need direct control over Signal key storage.
+
 ## Handling Events
 
 whalibmob uses the EventEmitter syntax for events.

package/cli.js

@@ -35,6 +35,8 @@ const {
   loadStore
 } = require('./lib/Client');
 
+const { assertMeId, initAuthCreds } = require('./lib/auth-utils');
+
 const VERSION = '5.1.21';
 
 // ─── output helpers ───────────────────────────────────────────────────────────
@@ -435,14 +437,18 @@ async function handleLine(line) {
         if (_client) { try { _client.disconnect(); } catch (_) {} }
         process.exit(0);
 
-      case '/session':
+      case '/session': {
         if (!_client || !_client.store) { fail('not connected'); break; }
+        let _meJid = '—';
+        try { _meJid = assertMeId(_client.store); } catch (_) {}
         hr();
         kv('phone',   _client.store.phoneNumber);
+        kv('jid',     _meJid);
         kv('name',    _client.store.pushName || _client.store.name || '—');
         kv('session', _sessDir);
         hr();
         break;
+      }
 
       case '/connect': {
         const ph = p[1];
@@ -1153,7 +1159,7 @@ async function handleLine(line) {
           const sessFile = path.join(_sessDir, `${ph}.json`);
           let store = loadStore(sessFile);
           if (!store) {
-            store = createNewStore(ph);
+            store = initAuthCreds(ph);
             saveStore(store, sessFile);
           } else if (!store.codePending && !store.registered) {
             // Only check /exist when keys were never used to request a code.
@@ -1162,7 +1168,7 @@ async function handleLine(line) {
             const fresh = await assertRegistrationKeys(store, waVersion);
             if (!fresh) {
               out('  device keys already registered — generating new keys...');
-              store = createNewStore(ph);
+              store = initAuthCreds(ph);
               saveStore(store, sessFile);
               out('  new keys saved — proceed with code below');
             }
@@ -1180,7 +1186,7 @@ async function handleLine(line) {
           const code = p[3];
           if (!ph || !code) { fail('usage: /reg confirm <phone> <code>'); break; }
           const file  = path.join(_sessDir, `${ph}.json`);
-          const store = loadStore(file) || createNewStore(ph);
+          const store = loadStore(file) || initAuthCreds(ph);
           out('verifying...');
           const r = await verifyCode(store, code);
           if (r && (r.status === 'ok' || r.status === 'sent' || r.status === 'verified')) {
@@ -1477,7 +1483,7 @@ async function main() {
       let store = loadStore(sessFile);
       if (!store) {
         // Brand new — generate fresh keys, save immediately, no need to check /exist
-        store = createNewStore(ph);
+        store = initAuthCreds(ph);
         saveStore(store, sessFile);
       } else if (!store.codePending && !store.registered) {
         // Existing store but code was never sent and not registered — check if
@@ -1488,7 +1494,7 @@ async function main() {
         const fresh = await assertRegistrationKeys(store, waVersion);
         if (!fresh) {
           out('  device keys already registered — generating new keys...');
-          store = createNewStore(ph);
+          store = initAuthCreds(ph);
           saveStore(store, sessFile);
         }
       }
@@ -1518,7 +1524,7 @@ async function main() {
       if (!ph)   { fail('phone number required'); process.exit(1); }
       if (!code) { fail('--code is required');    process.exit(1); }
       const file  = path.join(_sessDir, `${ph}.json`);
-      const store = loadStore(file) || createNewStore(ph);
+      const store = loadStore(file) || initAuthCreds(ph);
       out('verifying code for +' + ph + '...');
       try {
         const r = await verifyCode(store, code);

package/index.js

@@ -11,6 +11,12 @@ const { SenderKeyStore, SenderKeyCrypto } = require('./lib/signal/SenderKey');
 const { DeviceManager } = require('./lib/DeviceManager');
 const { encryptMedia, decryptMedia, uploadMedia, downloadMedia } = require('./lib/MediaService');
 const { MessageSender, makeJid, generateMessageId } = require('./lib/messages/MessageSender');
+const {
+  makeCacheableSignalKeyStore,
+  addTransactionCapability,
+  assertMeId,
+  initAuthCreds
+} = require('./lib/auth-utils');
 
 module.exports = {
   WhalibmobClient,
@@ -48,5 +54,10 @@ module.exports = {
   // Message helpers
   MessageSender,
   makeJid,
-  generateMessageId
+  generateMessageId,
+  // Auth utilities (mirrors Baileys' auth-utils)
+  makeCacheableSignalKeyStore,
+  addTransactionCapability,
+  assertMeId,
+  initAuthCreds
 };

package/lib/Client.js

@@ -175,6 +175,17 @@ class WhalibmobClient extends EventEmitter {
     this._signal = SignalProtocol.fromStore(this._store, signalFile, skFile);
     this._devMgr = new DeviceManager(this);
 
+    // Restore LID ↔ phone mappings persisted from previous sessions.
+    // This ensures we can route to LID JIDs even on fresh connections where no
+    // incoming message has yet populated _pnToLid during this session.
+    const persistedLid = this._signal.store.getLidMappings
+      ? this._signal.store.getLidMappings() : {};
+    for (const [phone, lid] of Object.entries(persistedLid)) {
+      this._pnToLid.set(phone, lid);
+      this._lidToPn.set(lid, phone);
+    }
+    process.stderr.write('[DBG] LID_RESTORED count=' + Object.keys(persistedLid).length + '\n');
+
     await this._connectSocket();
     return this;
   }
@@ -530,6 +541,10 @@ class WhalibmobClient extends EventEmitter {
       if (lidUser && pnUser && lidUser !== pnUser) {
         this._lidToPn.set(lidUser, pnUser);
         this._pnToLid.set(pnUser, lidUser);
+        // Persist so the mapping survives reconnects / process restarts
+        if (this._signal && this._signal.store && this._signal.store.setLidMapping) {
+          this._signal.store.setLidMapping(pnUser, lidUser);
+        }
       }
     }
     process.stderr.write('[DBG] _handleMessage from=' + from + ' participant=' + participant + ' senderPn=' + senderPn + ' id=' + id + '\n');
@@ -1196,6 +1211,8 @@ class WhalibmobClient extends EventEmitter {
             const pnUser = pPhone.split('@')[0].split(':')[0];
             this._lidToPn.set(lidUser, pnUser);
             this._pnToLid.set(pnUser, lidUser);
+            if (this._signal && this._signal.store && this._signal.store.setLidMapping)
+              this._signal.store.setLidMapping(pnUser, lidUser);
           }
         }
         // Case B: participant JID is a PN, lid attribute is their LID
@@ -1204,6 +1221,8 @@ class WhalibmobClient extends EventEmitter {
           const lidUser = pLid.split('@')[0].split(':')[0];
           this._lidToPn.set(lidUser, pnUser);
           this._pnToLid.set(pnUser, lidUser);
+          if (this._signal && this._signal.store && this._signal.store.setLidMapping)
+            this._signal.store.setLidMapping(pnUser, lidUser);
         }
         return { jid: pJid, role: pRole };
       });