whalibmob 5.5.22 → 5.5.23

package/.env.example

@@ -0,0 +1,49 @@
+# ─────────────────────────────────────────────────────────────────────────────
+# whalibmob — Device Emulation Configuration
+# Copy this file to .env in your project root and set the values you need.
+# All variables are optional; defaults emulate an iPhone 15 Pro running iOS 17.
+# ─────────────────────────────────────────────────────────────────────────────
+
+# Operating system to emulate.  Accepted values: ios | android
+# Default: ios
+# WA_OS=android
+
+# Named device profile.
+#
+# iOS profiles (WA_OS=ios):
+#   iphone_15_pro, iphone_15, iphone_14_pro, iphone_14, iphone_13_pro,
+#   iphone_13, iphone_12_pro, iphone_12, iphone_11_pro, iphone_11,
+#   iphone_se3, iphone_xs
+#
+# Android profiles (WA_OS=android):
+#   pixel_8_pro, pixel_8, pixel_7, pixel_7a,
+#   samsung_s24_ultra, samsung_s24, samsung_s23_ultra, samsung_s23, samsung_a55,
+#   oneplus_12, oneplus_11, xiaomi_14, xiaomi_13, oppo_find_x7, realme_gt5
+#
+# Default: iphone_15_pro  (or pixel_8_pro when WA_OS=android)
+# WA_DEVICE=pixel_8_pro
+
+# ── Custom device overrides (applied on top of the selected profile) ─────────
+# Use these to fine-tune any field without creating a new profile.
+
+# WA_DEVICE_MODEL=SM-S928B
+# WA_DEVICE_MANUFACTURER=samsung
+# WA_DEVICE_OS_VERSION=14
+# WA_DEVICE_BUILD=UP1A.231005.007
+# WA_DEVICE_MODEL_ID=samsung-sm-s928b
+
+# ── Version & token overrides ─────────────────────────────────────────────────
+
+# Pin the WhatsApp version string instead of fetching the latest from the store.
+# Format: 2.x.x.x  (four-part)
+# WA_VERSION=2.24.13.80
+
+# Override the static token used in registration token computation.
+# Only needed if WhatsApp rotates the bundled token.
+# WA_STATIC_TOKEN=Y29Cs6AVNR2bj5PBeKSYFd1nAKuvNQ3h
+
+# ── Proxy / Tor ───────────────────────────────────────────────────────────────
+
+# Route registration HTTP traffic through a SOCKS5 proxy or Tor.
+# TOR_PROXY=socks5://127.0.0.1:9050
+# SOCKS_PROXY=socks5://user:pass@proxy.example.com:1080

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/DeviceManager.js

@@ -1,6 +1,9 @@
 'use strict';
 
-const { BinaryNode } = require('./BinaryNode');
+const { BinaryNode }  = require('./BinaryNode');
+const { NodeCache }   = require('@cacheable/node-cache');
+
+const DEVICE_CACHE_TTL = '5m';
 
 // ─── JID helpers ─────────────────────────────────────────────────────────────
 
@@ -131,12 +134,37 @@ function parseBundleFromUserNode(userNode) {
 class DeviceManager {
   constructor(client) {
     this._client        = client;
-    // phone → Set<deviceId>  (populated after first usync)
-    this._deviceCache   = new Map();
+    // phone → deviceId[]  (TTL-based: expires after 5 min, triggers fresh usync)
+    this._deviceCache   = new NodeCache({ ttl: DEVICE_CACHE_TTL });
     // phone → Promise<jids[]>  (in-flight usync dedup)
     this._usyncInflight = new Map();
-    // own device list cache (populated once per connection)
-    this._ownDeviceJids = null;
+    // own device list cache + expiry timestamp (refreshed every 5 min)
+    this._ownDeviceJids   = null;
+    this._ownDeviceExpiry = 0;
+  }
+
+  // ─── NodeCache helper methods ─────────────────────────────────────────────
+  // _deviceCache stores deviceId arrays (not Sets) because NodeCache serialises
+  // values and Sets don't round-trip reliably.  All callers use these helpers.
+
+  _dcHas(key)       { return this._deviceCache.has(key); }
+  _dcGet(key)       { return this._deviceCache.get(key) || null; }   // number[] | null
+  _dcSet(key, arr)  { this._deviceCache.set(key, arr); }
+  _dcAdd(key, id) {
+    const arr = this._deviceCache.get(key) || [];
+    if (!arr.includes(id)) arr.push(id);
+    this._deviceCache.set(key, arr);
+  }
+  _dcEnsure(key) {
+    if (!this._deviceCache.has(key)) this._deviceCache.set(key, []);
+  }
+  _dcDel(keys) {
+    for (const k of keys) this._deviceCache.del(k);
+  }
+  _dcFlush() {
+    this._deviceCache.flushAll();
+    this._ownDeviceJids   = null;
+    this._ownDeviceExpiry = 0;
   }
 
   // ─── Fetch pre-key bundles for a list of JIDs via encrypt IQ ───────────────
@@ -222,8 +250,8 @@ class DeviceManager {
   // Only truly unknown phones trigger a network IQ.
 
   async _usyncGetDevices(phones) {
-    // Fast path: all phones cached
-    const uncached = phones.filter(p => !this._deviceCache.has(p));
+    // Fast path: all phones cached (TTL-based: NodeCache returns null for expired entries)
+    const uncached = phones.filter(p => !this._dcHas(p));
     if (uncached.length === 0) {
       return this._jidsFromCache(phones);
     }
@@ -250,8 +278,8 @@ class DeviceManager {
   _jidsFromCache(phones) {
     const jids = [];
     for (const p of phones) {
-      const devices = this._deviceCache.get(p);
-      if (devices && devices.size > 0) {
+      const devices = this._dcGet(p);
+      if (devices && devices.length > 0) {
         for (const dev of devices) jids.push(makeDeviceJid(p, dev));
       } else {
         jids.push(makeDeviceJid(p, 0));
@@ -374,9 +402,7 @@ class DeviceManager {
           const devicesNode    = findChild(userNode, 'devices');
           const deviceListNode = devicesNode ? findChild(devicesNode, 'device-list') : null;
 
-          if (!this._deviceCache.has(cachePhone)) {
-            this._deviceCache.set(cachePhone, new Set());
-          }
+          this._dcEnsure(cachePhone);
 
           if (deviceListNode && Array.isArray(deviceListNode.content)) {
             for (const devNode of deviceListNode.content) {
@@ -385,13 +411,13 @@ class DeviceManager {
               const devId = devNode.attrs && devNode.attrs.id != null
                 ? parseInt(String(devNode.attrs.id), 10)
                 : 0;
-              this._deviceCache.get(cachePhone).add(devId);
+              this._dcAdd(cachePhone, devId);
             }
             process.stderr.write('[DBG] USYNC_DEVICES phone=' + cachePhone +
-              ' ids=[' + [...this._deviceCache.get(cachePhone)].join(',') + ']\n');
+              ' ids=[' + (this._dcGet(cachePhone) || []).join(',') + ']\n');
           } else {
             // No device-list in response — fall back to device 0
-            this._deviceCache.get(cachePhone).add(0);
+            this._dcAdd(cachePhone, 0);
             process.stderr.write('[DBG] USYNC_NO_DEVLIST phone=' + cachePhone + ' → fallback id=0\n');
           }
         }
@@ -409,8 +435,8 @@ class DeviceManager {
 
     // For phones with no usync response at all, cache device 0 so we don't re-query
     for (const p of phones) {
-      if (!this._deviceCache.has(p)) {
-        this._deviceCache.set(p, new Set([0]));
+      if (!this._dcHas(p)) {
+        this._dcSet(p, [0]);
         process.stderr.write('[DBG] USYNC_FALLBACK phone=' + p + '\n');
       }
     }
@@ -476,19 +502,23 @@ class DeviceManager {
     const lidJid    = `${lidUser}@lid`;
     const cacheKey  = `lid:${lidUser}`;
 
-    // skipUsync=true: caller already knows the LID (from _pnToLid) — skip the
-    // usync round-trip and assume primary device 0.  Saves up to 15 s.
+    // skipUsync=true: skip usync ONLY if we already have a cache hit (i.e. we
+    // fetched this LID's devices in the last 5 min).  On a cache miss we MUST
+    // run a real usync even with skipUsync=true, otherwise linked devices (tablets,
+    // desktop, web) are silently ignored and only device 0 (primary phone) is used.
     if (skipUsync) {
-      if (!this._deviceCache.has(cacheKey)) {
-        this._deviceCache.set(cacheKey, new Set([0]));
-        process.stderr.write('[DBG] LID_SKIP_USYNC lidUser=' + lidUser + ' assume device=0\n');
+      if (!this._dcHas(cacheKey)) {
+        process.stderr.write('[DBG] LID_SKIP_USYNC_CACHE_MISS lidUser=' + lidUser + ' → real usync\n');
+        await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
+      } else {
+        process.stderr.write('[DBG] LID_SKIP_USYNC_HIT lidUser=' + lidUser + ' → cache\n');
       }
-    } else if (!this._deviceCache.has(cacheKey)) {
+    } else if (!this._dcHas(cacheKey)) {
       await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
     }
 
-    const deviceIds  = this._deviceCache.get(cacheKey) || new Set([0]);
-    const deviceJids = [...deviceIds].map(d => makeDeviceJid(lidUser, d, 'lid'));
+    const deviceIds  = this._dcGet(cacheKey) || [0];
+    const deviceJids = deviceIds.map(d => makeDeviceJid(lidUser, d, 'lid'));
 
     process.stderr.write('[DBG] LID_DEVICES lidUser=' + lidUser +
       ' deviceJids=[' + deviceJids.join(',') + ']\n');
@@ -635,9 +665,7 @@ class DeviceManager {
       return null;
     });
 
-    if (!this._deviceCache.has(cacheKey)) {
-      this._deviceCache.set(cacheKey, new Set());
-    }
+    this._dcEnsure(cacheKey);
 
     if (response) {
       const usyncNode = findChild(response, 'usync');
@@ -655,22 +683,22 @@ class DeviceManager {
               if (!devNode || devNode.description !== 'device') continue;
               const devId = devNode.attrs && devNode.attrs.id != null
                 ? parseInt(String(devNode.attrs.id), 10) : 0;
-              this._deviceCache.get(cacheKey).add(devId);
+              this._dcAdd(cacheKey, devId);
             }
             process.stderr.write('[DBG] USYNC_LID_DEVICES jid=' + jid +
-              ' ids=[' + [...this._deviceCache.get(cacheKey)].join(',') + ']\n');
+              ' ids=[' + (this._dcGet(cacheKey) || []).join(',') + ']\n');
           } else {
-            this._deviceCache.get(cacheKey).add(0);
+            this._dcAdd(cacheKey, 0);
             process.stderr.write('[DBG] USYNC_LID_NO_DEVLIST jid=' + jid + ' → fallback id=0\n');
           }
         }
       } else {
         process.stderr.write('[DBG] USYNC_LID_NO_LIST jid=' + jid + '\n');
-        this._deviceCache.get(cacheKey).add(0);
+        this._dcAdd(cacheKey, 0);
       }
     } else {
       process.stderr.write('[DBG] USYNC_LID_NULL_RESP jid=' + jid + '\n');
-      this._deviceCache.get(cacheKey).add(0);
+      this._dcAdd(cacheKey, 0);
     }
   }
 
@@ -681,15 +709,16 @@ class DeviceManager {
   //   from cache — zero extra network round-trips.
   //
   async ensureOwnDeviceSessions(ownPhone, signalProto, allowPkmsg = true) {
-    // If own device list is already cached, use it directly
-    if (this._ownDeviceJids !== null) {
+    // Use cached own device list if it hasn't expired (5-min TTL matches _deviceCache)
+    if (this._ownDeviceJids !== null && Date.now() < this._ownDeviceExpiry) {
       const others = this._ownDeviceJids.filter(j => stripUser(j).device !== 0);
       return this._ensureSessions(others, signalProto, allowPkmsg);
     }
 
-    // First call: query usync for own devices (same as before, but we cache the result)
-    const deviceJids   = await this._usyncGetDevices([ownPhone]);
-    this._ownDeviceJids = deviceJids;
+    // Cache miss or expired: re-query usync for own devices
+    const deviceJids      = await this._usyncGetDevices([ownPhone]);
+    this._ownDeviceJids   = deviceJids;
+    this._ownDeviceExpiry = Date.now() + 5 * 60 * 1000;
 
     const others = deviceJids.filter(j => stripUser(j).device !== 0);
     return this._ensureSessions(others, signalProto, allowPkmsg);
@@ -730,10 +759,9 @@ class DeviceManager {
   // ─── Invalidate cached device list (used on phash mismatch / 421 retry) ───
   clearCache(phones) {
     if (!phones || phones.length === 0) {
-      this._deviceCache.clear();
-      this._ownDeviceJids = null;
+      this._dcFlush();
     } else {
-      for (const p of phones) this._deviceCache.delete(p);
+      this._dcDel(phones);
     }
   }
 

package/lib/Registration.js

@@ -370,6 +370,7 @@ function toBase64Url(buf) {
 
 function buildPayload(store, waVersion, useToken, extraPairs) {
   const { cc, national } = parsePhone(store.phoneNumber);
+  const meta  = getCountryMeta(cc);
   const token = useToken ? computeToken(waVersion, national) : null;
   const fdid  = store.fdid.toUpperCase();
 
@@ -377,8 +378,8 @@ function buildPayload(store, waVersion, useToken, extraPairs) {
     'cc',         cc,
     'in',         national,
     'rc',         String(RELEASE_CHANNEL),
-    'lg',         'en',
-    'lc',         'US',
+    'lg',         meta.lg,
+    'lc',         meta.lc,
     'authkey',    toBase64Url(stripKeyPrefix(store.noiseKeyPair.public)),
     'e_regid',    toBase64Url(intToBytes(store.registrationId, 4)),
     'e_keytype',  toBase64Url(Buffer.from([SIGNAL_KEY_TYPE])),
@@ -601,11 +602,15 @@ async function requestSmsCode(store, method) {
   const fallbackMethod = method === 'wa_old' ? 'sms' : (method === 'sms' ? 'wa_old' : 'sms');
   let autoFallbackDone = false;
 
+  // Derive real MCC/MNC from the phone number being registered.
+  const { cc: _regCc } = parsePhone(store.phoneNumber);
+  const _regMeta       = getCountryMeta(_regCc);
+
   async function _tryMethod(m) {
     const extra = [
       'method',            m,
-      'sim_mcc',           '000',
-      'sim_mnc',           '000',
+      'sim_mcc',           _regMeta.mcc,
+      'sim_mnc',           _regMeta.mnc,
       'reason',            '',
       'cellular_strength', '1'
     ];
@@ -706,4 +711,4 @@ async function verifyCode(store, code) {
   throw new Error(`Verification failed: ${reason || JSON.stringify(result)}`);
 }
 
-module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchWaVersion, parsePhone, assertRegistrationKeys };
+module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchWaVersion, parsePhone, getCountryMeta, assertRegistrationKeys };