whalibmob 5.14.6 → 5.14.8

package/lib/Client.js

@@ -171,6 +171,17 @@ const PING_INTERVAL_MS    = 25000;
 const KEEPALIVE_INTERVAL  = 20000;
 const RECONNECT_BACKOFF   = [1000, 2000, 4000, 8000, 15000, 30000];
 
+// When the server is down to this many one-time keys or fewer, send it more.
+// The number is small on purpose: the server tells us when it is running low,
+// and this is the floor for the case where that notice never arrives.
+const PRE_KEY_SERVER_MIN  = 5;
+
+// How often to ask the server how many it has left. The drain is invisible from
+// here — every bundle handed out is a key gone, and none of that reaches this
+// side — so on a session that stays up for days this is the only thing that
+// notices before the pool is empty and the account stops being reachable.
+const PRE_KEY_CHECK_INTERVAL = 30 * 60 * 1000;   // 30 minutes
+
 // ─── Key helpers ──────────────────────────────────────────────────────────────
 
 function intToBytes(n, byteLen) {
@@ -1234,7 +1245,12 @@ class WhalibmobClient extends EventEmitter {
     this.setOnline(true);
 
     this._requestMediaConnection();
-    this._uploadPreKeys();
+    // Ask what the server still has rather than uploading blind. It answers
+    // with a number this side has no other way of learning, and then with the
+    // bundle it is serving, which is the thing that goes quietly wrong and
+    // takes the account's reachability with it.
+    this._ensureServerPreKeys('login')
+      .then(() => this._verifyServerKeyBundle('login'));
 
     // Same telemetry ping the web client sends on every completed login.
     this._sendUnifiedSession();
@@ -1500,9 +1516,23 @@ class WhalibmobClient extends EventEmitter {
     }
 
     if (collections.size === 0) return;
-    this.syncAppState([...collections]).catch(err => {
-      _whaDbg('[DBG] APP_STATE sync failed: ' + (err && err.message));
-    });
+
+    // The bit has to be cleared whatever came of the sync. A session that
+    // cannot sync at all — no key has ever been shared with it, which is every
+    // session that registered its own number — would otherwise leave it set
+    // forever and be told about the same change on every single connection.
+    const clearAll = () => {
+      for (const type of dirtyTypes) {
+        if (COLLECTION_MAP[type]) this._cleanDirtyBits(type);
+      }
+    };
+
+    this.syncAppState([...collections])
+      .then(clearAll)
+      .catch(err => {
+        _whaDbg('[DBG] APP_STATE sync failed: ' + (err && err.message));
+        clearAll();
+      });
   }
 
   /**
@@ -1920,11 +1950,20 @@ class WhalibmobClient extends EventEmitter {
         }, [new BinaryNode('ping', {}, null)]));
       }
     }, KEEPALIVE_INTERVAL);
+
+    // The server is supposed to say when it is running out of one-time keys,
+    // and mostly does. This is for when it does not: a session that stays up
+    // long enough can be drained without a word, and the first sign of it is
+    // that nobody can reach the account any more.
+    this._preKeyTimer = setInterval(() => {
+      if (this._socket && this._connected) this._ensureServerPreKeys('periodic');
+    }, PRE_KEY_CHECK_INTERVAL);
   }
 
   _stopTimers() {
-    if (this._pingTimer) { clearInterval(this._pingTimer); this._pingTimer = null; }
-    if (this._keepTimer) { clearInterval(this._keepTimer); this._keepTimer = null; }
+    if (this._pingTimer)   { clearInterval(this._pingTimer);   this._pingTimer   = null; }
+    if (this._keepTimer)   { clearInterval(this._keepTimer);   this._keepTimer   = null; }
+    if (this._preKeyTimer) { clearInterval(this._preKeyTimer); this._preKeyTimer = null; }
   }
 
   // ─── Node dispatch ────────────────────────────────────────────────────────
@@ -3005,15 +3044,28 @@ class WhalibmobClient extends EventEmitter {
       // whole dispatch down with it, so every notification behind it in the
       // offline queue was dropped too.
       const fromJid   = String(attrs.from || '');
-      const fromPhone = fromJid.split('@')[0].split(':')[0];
-      if (fromPhone && this._devMgr) {
-        this._devMgr._dcDel([fromPhone]);
-        _whaDbg('[DBG] NOTIF_DEVICES invalidated cache for ' + fromPhone);
+      const fromUser  = fromJid.split('@')[0].split(':')[0];
+      // The user segment of a LID is not a phone number, and usync only takes
+      // phone numbers — asking it about a LID comes back "invalid" and the
+      // device list is never actually refreshed. Translate first when we know
+      // the mapping, and when we do not, invalidate the cache and stop there
+      // rather than spending an IQ on a question that cannot be answered.
+      const isLid     = fromJid.endsWith('@lid');
+      const mappedPn  = isLid && this._lidToPn ? this._lidToPn.get(fromUser) : null;
+      const fromPhone = isLid ? mappedPn : fromUser;
+      if (fromUser && this._devMgr) {
+        this._devMgr._dcDel(isLid ? [fromUser, 'lid:' + fromUser] : [fromUser]);
+        if (mappedPn) this._devMgr._dcDel([mappedPn]);
+        _whaDbg('[DBG] NOTIF_DEVICES invalidated cache for ' + fromUser +
+          (isLid ? (mappedPn ? ' (lid → ' + mappedPn + ')' : ' (lid, no phone known)') : ''));
         // Also process any inline <devices> list the server included
         const devicesNode = findChildDeep(node, 'devices');
         if (devicesNode) this._processDeviceUpdate(devicesNode);
-        // Background re-usync so the cache is warm before the next send
-        if (this._signal) {
+        // Background re-usync so the cache is warm before the next send. Only
+        // when there is a phone number to ask about — the cache is already
+        // cleared, so a LID with no known number simply gets looked up the next
+        // time something sends to it.
+        if (this._signal && fromPhone) {
           setImmediate(() => {
             if (!this._connected || !this._devMgr) return;
             this._devMgr.bulkEnsureSessions([fromPhone], this._signal, false)
@@ -3320,15 +3372,187 @@ class WhalibmobClient extends EventEmitter {
     ]));
   }
 
-  _checkAndReplenishPreKeys() {
+  // How many one-time keys the server is still holding for us.
+  //
+  // This is the number that matters and the one we could not see. The local
+  // store only loses a key when a pkmsg using it is actually decrypted, while
+  // the server hands one out to everybody who asks for a bundle — including the
+  // ones who then never write. So the two drift apart, and the local count can
+  // sit at its full 800 while the server has none left. With none left nobody
+  // can open a session with this account at all: the messages are not delayed,
+  // they are never sent, which is why nothing arrives and nothing is queued.
+  //
+  // The two client families ask differently, so each is asked its own way. A
+  // companion asks for a count and is told a number. A primary asks for the
+  // digest and is given the ids it holds, which is the same answer with the
+  // arithmetic left to us.
+  async _queryServerPreKeyCount() {
+    if (!this._socket || !this._connected) return null;
+
+    const web  = this._mode === 'web';
+    const resp = await this._sendIq(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'get',
+      xmlns: 'encrypt'
+    }, [new BinaryNode(web ? 'count' : 'digest', {}, null)]));
+
+    if (!resp) return null;                                   // timed out
+    if (resp.attrs && resp.attrs.type === 'error') return null;
+
+    if (web) {
+      const countNode = findChild(resp, 'count');
+      const value     = countNode && countNode.attrs && countNode.attrs.value;
+      const n         = value === undefined ? NaN : Number(value);
+      return Number.isFinite(n) ? n : null;
+    }
+
+    // <digest><list><...one child per key we still have there...></list></digest>
+    const digest = findChild(resp, 'digest');
+    const list   = digest && findChild(digest, 'list');
+    if (!list) return null;
+    return Array.isArray(list.content) ? list.content.length : 0;
+  }
+
+  // What the server believes this account's key bundle is.
+  //
+  // The digest is the only way to see it. Everything else here is a guess about
+  // what was uploaded once and assumed to have stuck — and when the server's
+  // idea of the bundle and ours part company, nobody can open a session with
+  // this account and there is no error anywhere to say so. It is the state that
+  // registering the number again clears, which is why registering again is what
+  // has been fixing it.
+  async _queryKeyDigest() {
+    if (!this._socket || !this._connected) return null;
+
+    const resp = await this._sendIq(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'get',
+      xmlns: 'encrypt'
+    }, [new BinaryNode('digest', {}, null)]));
+
+    if (!resp) return null;
+    if (resp.attrs && resp.attrs.type === 'error') return null;
+
+    const digest = findChild(resp, 'digest');
+    if (!digest) return { missing: true };
+
+    const bytesOf = (parent, tag) => {
+      const n = parent && findChild(parent, tag);
+      if (!n) return null;
+      if (Buffer.isBuffer(n.content)) return n.content;
+      return n.content ? Buffer.from(n.content) : null;
+    };
+
+    const skey = findChild(digest, 'skey');
+    const list = findChild(digest, 'list');
+    return {
+      missing:    false,
+      identity:   bytesOf(digest, 'identity'),
+      skeyId:     bytesOf(skey, 'id'),
+      skeyValue:  bytesOf(skey, 'value'),
+      preKeyCount: list && Array.isArray(list.content) ? list.content.length : 0
+    };
+  }
+
+  // Compare that bundle against the one we hold, and re-upload when they differ.
+  //
+  // Only values the server states outright are compared — the identity key and
+  // the signed pre-key it is serving — so nothing here depends on guessing how
+  // it hashes them. A mismatch means the bundle other people are handed is not
+  // the one this session can answer for, and no amount of waiting fixes that.
+  async _verifyServerKeyBundle(reason) {
     if (!this._signal) return;
-    const count = this._signal.preKeyCount();
-    if (count < 20) {
-      const newKeys = this._signal.replenishPreKeys();
-      if (newKeys.length > 0) this._uploadPreKeys();
+    try {
+      const digest = await this._queryKeyDigest();
+      if (!digest) return;                       // no answer; nothing to conclude
+
+      if (digest.missing) {
+        _whaDbg('[DBG] KEYBUNDLE server returned no digest (' + reason + ') — re-uploading');
+        this._replenishLocalPreKeys();
+        this._uploadPreKeys();
+        return;
+      }
+
+      const bare      = (b) => (b && b.length === 33 && b[0] === 0x05) ? b.slice(1) : b;
+      const ourIdent  = bare(this._signal.getIdentityKey());
+      const ourSpk    = this._signal.getSignedPreKeyForUpload();
+      const ourSpkPub = ourSpk && bare(ourSpk.keyPair.pubKey);
+
+      const mismatches = [];
+      if (digest.identity && ourIdent &&
+          Buffer.compare(digest.identity, ourIdent) !== 0) {
+        mismatches.push('identity key');
+      }
+      if (digest.skeyValue && ourSpkPub &&
+          Buffer.compare(digest.skeyValue, ourSpkPub) !== 0) {
+        mismatches.push('signed pre-key');
+      }
+      if (digest.skeyId && ourSpk) {
+        let served = 0;
+        for (const b of digest.skeyId) served = (served << 8) | b;
+        if (served !== ourSpk.keyId) mismatches.push('signed pre-key id (' + served +
+          ' vs ' + ourSpk.keyId + ')');
+      }
+
+      if (!mismatches.length) {
+        _whaDbg('[DBG] KEYBUNDLE matches the server (' + reason + '), ' +
+          digest.preKeyCount + ' one-time key(s) there');
+        return;
+      }
+
+      _whaDbg('[DBG] KEYBUNDLE server disagrees on ' + mismatches.join(' and ') +
+        ' (' + reason + ') — re-uploading');
+      this._replenishLocalPreKeys();
+      this._uploadPreKeys();
+    } catch (err) {
+      _whaDbg('[DBG] KEYBUNDLE check failed (' + reason + '): ' + (err && err.message));
+    }
+  }
+
+  // Top the server back up when it is running out. Never throws: a session that
+  // cannot ask is left exactly as it was rather than losing its connection over
+  // a bookkeeping query.
+  async _ensureServerPreKeys(reason) {
+    if (!this._signal) return;
+    try {
+      const serverCount = await this._queryServerPreKeyCount();
+      if (serverCount === null) {
+        // No usable answer. Fall back to the old behaviour — an upload we may
+        // not have needed costs nothing next to an account nobody can reach.
+        _whaDbg('[DBG] PREKEY server count unavailable (' + reason + ') — uploading anyway');
+        this._replenishLocalPreKeys();
+        this._uploadPreKeys();
+        return;
+      }
+
+      _whaDbg('[DBG] PREKEY server holds ' + serverCount + ' (' + reason + ')');
+      if (serverCount > PRE_KEY_SERVER_MIN) return;
+
+      _whaDbg('[DBG] PREKEY server low (' + serverCount + ' <= ' + PRE_KEY_SERVER_MIN +
+        ') — uploading');
+      this._replenishLocalPreKeys();
+      this._uploadPreKeys();
+    } catch (err) {
+      _whaDbg('[DBG] PREKEY check failed (' + reason + '): ' + (err && err.message));
     }
   }
 
+  // Make sure there is something to upload before uploading.
+  _replenishLocalPreKeys() {
+    if (!this._signal) return;
+    if (this._signal.preKeyCount() < 20) this._signal.replenishPreKeys();
+  }
+
+  _checkAndReplenishPreKeys() {
+    if (!this._signal) return;
+    // The server said it is running low, so ask it how low and act on that
+    // rather than on the local count, which does not move when the server
+    // hands a key out.
+    this._ensureServerPreKeys('server asked');
+  }
+
   // ─── IQ helper (send + await response) ────────────────────────────────────
 
   _sendIq(node) {

package/lib/Registration.js

@@ -418,6 +418,149 @@ const COUNTRY_META = {
   '971': { mcc: '424', mnc: '02',  lg: 'ar', lc: 'AE' }, // UAE
   '972': { mcc: '425', mnc: '01',  lg: 'he', lc: 'IL' }, // Israel
   '880': { mcc: '470', mnc: '01',  lg: 'bn', lc: 'BD' }, // Bangladesh
+  // Filled in from the ITU mobile-network tables so a number from anywhere
+  // reports the carrier its country actually has. Without an entry a session
+  // falls back to 000/000, which is what a handset with no SIM card reports.
+  // One operational national operator per country; the point is a plausible
+  // home network, not a particular one.
+  '53':    { mcc: '368', mnc: '01', lg: 'es', lc: 'CU' }, // Cuba (CUBACEL)
+  '211':   { mcc: '659', mnc: '02', lg: 'en', lc: 'SS' }, // South Sudan (MTN)
+  '220':   { mcc: '607', mnc: '01', lg: 'en', lc: 'GM' }, // Gambia (Gamcel)
+  '221':   { mcc: '608', mnc: '01', lg: 'fr', lc: 'SN' }, // Senegal (Orange)
+  '222':   { mcc: '609', mnc: '01', lg: 'ar', lc: 'MR' }, // Mauritania (Mattel)
+  '223':   { mcc: '610', mnc: '01', lg: 'fr', lc: 'ML' }, // Mali (Malitel)
+  '224':   { mcc: '611', mnc: '01', lg: 'fr', lc: 'GN' }, // Guinea (Orange)
+  '225':   { mcc: '612', mnc: '02', lg: 'fr', lc: 'CI' }, // Ivory Coast (Moov)
+  '226':   { mcc: '613', mnc: '01', lg: 'fr', lc: 'BF' }, // Burkina Faso (Telmob)
+  '227':   { mcc: '614', mnc: '01', lg: 'fr', lc: 'NE' }, // Niger (SahelCom)
+  '228':   { mcc: '615', mnc: '01', lg: 'fr', lc: 'TG' }, // Togo (Togo Cell)
+  '229':   { mcc: '616', mnc: '01', lg: 'fr', lc: 'BJ' }, // Benin (Benin Telecoms Mob)
+  '230':   { mcc: '617', mnc: '01', lg: 'en', lc: 'MU' }, // Mauritius (my.t)
+  '231':   { mcc: '618', mnc: '01', lg: 'en', lc: 'LR' }, // Liberia (Lonestar Cell MTN)
+  '232':   { mcc: '619', mnc: '01', lg: 'en', lc: 'SL' }, // Sierra Leone (Orange)
+  '233':   { mcc: '620', mnc: '01', lg: 'en', lc: 'GH' }, // Ghana (MTN)
+  '235':   { mcc: '622', mnc: '01', lg: 'ar', lc: 'TD' }, // Chad (Airtel)
+  '236':   { mcc: '623', mnc: '01', lg: 'fr', lc: 'CF' }, // Central African Republic (Moov)
+  '237':   { mcc: '624', mnc: '01', lg: 'en', lc: 'CM' }, // Cameroon (MTN Cameroon)
+  '238':   { mcc: '625', mnc: '01', lg: 'pt', lc: 'CV' }, // Cape Verde (CVMOVEL)
+  '239':   { mcc: '626', mnc: '01', lg: 'pt', lc: 'ST' }, // São Tomé and Príncipe (CSTmovel)
+  '240':   { mcc: '627', mnc: '01', lg: 'fr', lc: 'GQ' }, // Equatorial Guinea (Orange GQ)
+  '241':   { mcc: '628', mnc: '01', lg: 'fr', lc: 'GA' }, // Gabon (Libertis)
+  '242':   { mcc: '629', mnc: '01', lg: 'fr', lc: 'CG' }, // Republic of the Congo (Airtel)
+  '243':   { mcc: '630', mnc: '01', lg: 'fr', lc: 'CD' }, // DR Congo (Vodacom)
+  '244':   { mcc: '631', mnc: '02', lg: 'pt', lc: 'AO' }, // Angola (UNITEL)
+  '245':   { mcc: '632', mnc: '01', lg: 'pt', lc: 'GW' }, // Guinea-Bissau (Guinetel)
+  '248':   { mcc: '633', mnc: '01', lg: 'en', lc: 'SC' }, // Seychelles (Cable & Wireless)
+  '249':   { mcc: '634', mnc: '01', lg: 'ar', lc: 'SD' }, // Sudan (Zain SD)
+  '250':   { mcc: '635', mnc: '10', lg: 'en', lc: 'RW' }, // Rwanda (MTN)
+  '251':   { mcc: '636', mnc: '01', lg: 'am', lc: 'ET' }, // Ethiopia (MTN)
+  '252':   { mcc: '637', mnc: '01', lg: 'ar', lc: 'SO' }, // Somalia (Telesom)
+  '253':   { mcc: '638', mnc: '01', lg: 'ar', lc: 'DJ' }, // Djibouti (Evatis)
+  '257':   { mcc: '642', mnc: '01', lg: 'fr', lc: 'BI' }, // Burundi (econet Leo)
+  '258':   { mcc: '643', mnc: '01', lg: 'pt', lc: 'MZ' }, // Mozambique (mCel)
+  '260':   { mcc: '645', mnc: '01', lg: 'en', lc: 'ZM' }, // Zambia (Airtel)
+  '261':   { mcc: '646', mnc: '01', lg: 'fr', lc: 'MG' }, // Madagascar (Airtel)
+  '263':   { mcc: '648', mnc: '01', lg: 'en', lc: 'ZW' }, // Zimbabwe (Net*One)
+  '264':   { mcc: '649', mnc: '01', lg: 'af', lc: 'NA' }, // Namibia (MTC)
+  '265':   { mcc: '650', mnc: '01', lg: 'en', lc: 'MW' }, // Malawi (TNM)
+  '266':   { mcc: '651', mnc: '01', lg: 'en', lc: 'LS' }, // Lesotho (Vodacom)
+  '267':   { mcc: '652', mnc: '01', lg: 'en', lc: 'BW' }, // Botswana (Mascom)
+  '268':   { mcc: '653', mnc: '02', lg: 'en', lc: 'SZ' }, // Eswatini (Eswatini Mobile Li)
+  '269':   { mcc: '654', mnc: '01', lg: 'ar', lc: 'KM' }, // Comoros (HURI)
+  '290':   { mcc: '658', mnc: '01', lg: 'en', lc: 'SH' }, // Saint Helena, Ascension and Tristan da Cunha (Sure)
+  '291':   { mcc: '657', mnc: '01', lg: 'ar', lc: 'ER' }, // Eritrea (Eritel)
+  '297':   { mcc: '363', mnc: '01', lg: 'nl', lc: 'AW' }, // Aruba (SETAR)
+  '298':   { mcc: '288', mnc: '01', lg: 'da', lc: 'FO' }, // Faroe Islands (Føroya Tele)
+  '299':   { mcc: '290', mnc: '01', lg: 'kl', lc: 'GL' }, // Greenland (tusass)
+  '350':   { mcc: '266', mnc: '01', lg: 'en', lc: 'GI' }, // Gibraltar (GibTel)
+  '352':   { mcc: '270', mnc: '01', lg: 'de', lc: 'LU' }, // Luxembourg (POST)
+  '354':   { mcc: '274', mnc: '01', lg: 'is', lc: 'IS' }, // Iceland (Síminn)
+  '355':   { mcc: '276', mnc: '01', lg: 'sq', lc: 'AL' }, // Albania (ONE)
+  '356':   { mcc: '278', mnc: '01', lg: 'en', lc: 'MT' }, // Malta (Epic)
+  '357':   { mcc: '280', mnc: '01', lg: 'el', lc: 'CY' }, // Cyprus (Cytamobile-Vodafon)
+  '359':   { mcc: '284', mnc: '01', lg: 'bg', lc: 'BG' }, // Bulgaria (A1 BG)
+  '370':   { mcc: '246', mnc: '01', lg: 'lt', lc: 'LT' }, // Lithuania (Telia)
+  '371':   { mcc: '247', mnc: '01', lg: 'lv', lc: 'LV' }, // Latvia (LMT)
+  '372':   { mcc: '248', mnc: '01', lg: 'et', lc: 'EE' }, // Estonia (Telia)
+  '373':   { mcc: '255', mnc: '00', lg: 'ro', lc: 'MD' }, // Moldova (IDC)
+  '374':   { mcc: '283', mnc: '01', lg: 'hy', lc: 'AM' }, // Armenia (Beeline)
+  '375':   { mcc: '257', mnc: '01', lg: 'be', lc: 'BY' }, // Belarus (A1)
+  '376':   { mcc: '213', mnc: '03', lg: 'ca', lc: 'AD' }, // Andorra (Som, Mobiland)
+  '377':   { mcc: '212', mnc: '10', lg: 'fr', lc: 'MC' }, // Monaco (Office des Telepho)
+  '378':   { mcc: '292', mnc: '01', lg: 'it', lc: 'SM' }, // San Marino (PRIMA)
+  '381':   { mcc: '220', mnc: '01', lg: 'sr', lc: 'RS' }, // Serbia (Yettel)
+  '382':   { mcc: '297', mnc: '01', lg: 'en', lc: 'ME' }, // Montenegro (One)
+  '383':   { mcc: '221', mnc: '01', lg: 'sq', lc: 'XK' }, // Kosovo (Vala)
+  '385':   { mcc: '219', mnc: '01', lg: 'hr', lc: 'HR' }, // Croatia (HT HR)
+  '386':   { mcc: '293', mnc: '10', lg: 'sl', lc: 'SI' }, // Slovenia (SŽ - Infrastruktur)
+  '387':   { mcc: '218', mnc: '03', lg: 'bs', lc: 'BA' }, // Bosnia and Herzegovina (HT-ERONET)
+  '389':   { mcc: '294', mnc: '01', lg: 'mk', lc: 'MK' }, // North Macedonia (Telekom.mk)
+  '421':   { mcc: '231', mnc: '01', lg: 'sk', lc: 'SK' }, // Slovakia (Orange)
+  '423':   { mcc: '295', mnc: '01', lg: 'de', lc: 'LI' }, // Liechtenstein (Swisscom)
+  '500':   { mcc: '750', mnc: '001', lg: 'en', lc: 'FK' }, // Falkland Islands (Sure)
+  '501':   { mcc: '702', mnc: '67', lg: 'en', lc: 'BZ' }, // Belize (DigiCell)
+  '502':   { mcc: '704', mnc: '?', lg: 'es', lc: 'GT' }, // Guatemala (RED/INTELFON)
+  '503':   { mcc: '706', mnc: '01', lg: 'es', lc: 'SV' }, // El Salvador (Claro)
+  '504':   { mcc: '708', mnc: '001', lg: 'es', lc: 'HN' }, // Honduras (Claro)
+  '505':   { mcc: '710', mnc: '21', lg: 'es', lc: 'NI' }, // Nicaragua (Claro)
+  '506':   { mcc: '712', mnc: '01', lg: 'es', lc: 'CR' }, // Costa Rica (Kölbi ICE)
+  '507':   { mcc: '714', mnc: '01', lg: 'es', lc: 'PA' }, // Panama (Cable & Wireless)
+  '508':   { mcc: '308', mnc: '01', lg: 'fr', lc: 'PM' }, // Saint Pierre and Miquelon (Ameris)
+  '509':   { mcc: '372', mnc: '02', lg: 'fr', lc: 'HT' }, // Haiti (Digicel)
+  '591':   { mcc: '736', mnc: '01', lg: 'ay', lc: 'BO' }, // Bolivia (Viva)
+  '592':   { mcc: '738', mnc: '00', lg: 'en', lc: 'GY' }, // Guyana (E-Networks)
+  '593':   { mcc: '740', mnc: '00', lg: 'es', lc: 'EC' }, // Ecuador (Movistar)
+  '594':   { mcc: '340', mnc: '01', lg: 'fr', lc: 'GF' }, // French Guiana (Orange)
+  '595':   { mcc: '744', mnc: '01', lg: 'gn', lc: 'PY' }, // Paraguay (VOX)
+  '597':   { mcc: '746', mnc: '02', lg: 'nl', lc: 'SR' }, // Suriname (Telesur)
+  '598':   { mcc: '748', mnc: '01', lg: 'es', lc: 'UY' }, // Uruguay (Antel)
+  '670':   { mcc: '514', mnc: '01', lg: 'pt', lc: 'TL' }, // Timor-Leste (Telkomcel)
+  '672':   { mcc: '505', mnc: '10', lg: 'en', lc: 'NF' }, // Norfolk Island (Norfolk Telecom)
+  '673':   { mcc: '528', mnc: '02', lg: 'ms', lc: 'BN' }, // Brunei (PCSB)
+  '674':   { mcc: '536', mnc: '02', lg: 'en', lc: 'NR' }, // Nauru (Digicel)
+  '675':   { mcc: '537', mnc: '01', lg: 'en', lc: 'PG' }, // Papua New Guinea (bmobile)
+  '676':   { mcc: '539', mnc: '01', lg: 'en', lc: 'TO' }, // Tonga (U-Call)
+  '677':   { mcc: '540', mnc: '01', lg: 'en', lc: 'SB' }, // Solomon Islands (BREEZE)
+  '678':   { mcc: '541', mnc: '00', lg: 'bi', lc: 'VU' }, // Vanuatu (AIL)
+  '679':   { mcc: '542', mnc: '01', lg: 'en', lc: 'FJ' }, // Fiji (Vodafone)
+  '680':   { mcc: '552', mnc: '01', lg: 'en', lc: 'PW' }, // Palau (PNCC)
+  '681':   { mcc: '543', mnc: '01', lg: 'fr', lc: 'WF' }, // Wallis and Futuna (Manuia)
+  '682':   { mcc: '548', mnc: '01', lg: 'en', lc: 'CK' }, // Cook Islands (Vodafone)
+  '683':   { mcc: '555', mnc: '01', lg: 'en', lc: 'NU' }, // Niue (Telecom Niue)
+  '685':   { mcc: '549', mnc: '01', lg: 'en', lc: 'WS' }, // Samoa (Digicel)
+  '686':   { mcc: '545', mnc: '01', lg: 'en', lc: 'KI' }, // Kiribati (Kiribati - ATH)
+  '687':   { mcc: '546', mnc: '01', lg: 'fr', lc: 'NC' }, // New Caledonia (Mobilis)
+  '688':   { mcc: '553', mnc: '01', lg: 'en', lc: 'TV' }, // Tuvalu (TTC)
+  '689':   { mcc: '547', mnc: '05', lg: 'fr', lc: 'PF' }, // French Polynesia (Ora)
+  '690':   { mcc: '554', mnc: '01', lg: 'en', lc: 'TK' }, // Tokelau (Teletok)
+  '691':   { mcc: '550', mnc: '01', lg: 'en', lc: 'FM' }, // Micronesia (FSMTC)
+  '692':   { mcc: '551', mnc: '01', lg: 'en', lc: 'MH' }, // Marshall Islands (Marshall Islands N)
+  '850':   { mcc: '467', mnc: '05', lg: 'ko', lc: 'KP' }, // North Korea (Koryolink)
+  '852':   { mcc: '454', mnc: '00', lg: 'en', lc: 'HK' }, // Hong Kong (1O1O / One2Free / )
+  '853':   { mcc: '455', mnc: '00', lg: 'pt', lc: 'MO' }, // Macau (SmarTone)
+  '855':   { mcc: '456', mnc: '01', lg: 'km', lc: 'KH' }, // Cambodia (Cellcard)
+  '856':   { mcc: '457', mnc: '01', lg: 'lo', lc: 'LA' }, // Laos (LaoTel)
+  '886':   { mcc: '466', mnc: '01', lg: 'zh', lc: 'TW' }, // Taiwan (FarEasTone)
+  '960':   { mcc: '472', mnc: '01', lg: 'dv', lc: 'MV' }, // Maldives (Dhiraagu)
+  '961':   { mcc: '415', mnc: '01', lg: 'ar', lc: 'LB' }, // Lebanon (Alfa)
+  '962':   { mcc: '416', mnc: '01', lg: 'ar', lc: 'JO' }, // Jordan (zain JO)
+  '963':   { mcc: '417', mnc: '01', lg: 'ar', lc: 'SY' }, // Syria (Syriatel)
+  '964':   { mcc: '418', mnc: '00', lg: 'ar', lc: 'IQ' }, // Iraq (Asia Cell)
+  '965':   { mcc: '419', mnc: '02', lg: 'ar', lc: 'KW' }, // Kuwait (zain KW)
+  '967':   { mcc: '421', mnc: '01', lg: 'ar', lc: 'YE' }, // Yemen (SabaFon)
+  '968':   { mcc: '422', mnc: '02', lg: 'ar', lc: 'OM' }, // Oman (Omantel)
+  '970':   { mcc: '425', mnc: '05', lg: 'ar', lc: 'PS' }, // Palestine (Jawwal)
+  '973':   { mcc: '426', mnc: '01', lg: 'ar', lc: 'BH' }, // Bahrain (Batelco)
+  '974':   { mcc: '427', mnc: '01', lg: 'ar', lc: 'QA' }, // Qatar (Ooredoo)
+  '975':   { mcc: '402', mnc: '11', lg: 'dz', lc: 'BT' }, // Bhutan (B-Mobile)
+  '976':   { mcc: '428', mnc: '88', lg: 'mn', lc: 'MN' }, // Mongolia (Unitel)
+  '977':   { mcc: '429', mnc: '01', lg: 'ne', lc: 'NP' }, // Nepal (Namaste / NT Mobil)
+  '992':   { mcc: '436', mnc: '01', lg: 'ru', lc: 'TJ' }, // Tajikistan (Tcell)
+  '993':   { mcc: '438', mnc: '02', lg: 'ru', lc: 'TM' }, // Turkmenistan (TM-Cell)
+  '994':   { mcc: '400', mnc: '01', lg: 'az', lc: 'AZ' }, // Azerbaijan (Azercell)
+  '995':   { mcc: '282', mnc: '01', lg: 'ka', lc: 'GE' }, // Georgia (Geocell)
+  '996':   { mcc: '437', mnc: '01', lg: 'ky', lc: 'KG' }, // Kyrgyzstan (Beeline)
+  '998':   { mcc: '434', mnc: '03', lg: 'ru', lc: 'UZ' }, // Uzbekistan (UzMobile)
 };
 
 function getCountryMeta(cc) {
@@ -431,17 +574,20 @@ function getCountryMeta(cc) {
 //              (Java long conversion removes them automatically)
 
 const THREE_DIGIT_CCS = new Set([
-  '355','213','376','244','672','374','297','994','387','1246','880','226',
-  '599','1242','975','267','257','229','590','673','591','238','682','237',
-  '236','242','225','269','506','53','357','253','1767','291','240','251',
-  '372','500','298','241','995','594','233','299','220','224','245','592',
-  '504','353','246','964','354','962','996','855','686','850','965','7',
-  '856','423','231','266','370','352','218','261','692','692','389','223',
-  '692','222','960','265','692','976','853','258','264','977','674','505',
-  '687','227','968','507','675','689','680','595','974','692','250','677',
-  '248','963','503','268','235','228','676','1868','688','255','993','690',
-  '670','598','678','685','967','692','262','964','993','1784','1242','371',
-  '1473','692','1268','692','1869','692'
+  '211','212','213','216','218','220','221','222','223','224','225','226',
+  '227','228','229','230','231','232','233','234','235','236','237','238',
+  '239','240','241','242','243','244','245','246','247','248','249','250',
+  '251','252','253','254','255','256','257','258','260','261','262','263',
+  '264','265','266','267','268','269','290','291','297','298','299','350',
+  '351','352','353','354','355','356','357','358','359','370','371','372',
+  '373','374','375','376','377','378','380','381','382','383','385','386',
+  '387','389','420','421','423','500','501','502','503','504','505','506',
+  '507','508','509','590','591','592','593','594','595','596','597','598',
+  '599','670','672','673','674','675','676','677','678','679','680','681',
+  '682','683','685','686','687','688','689','690','691','692','850','852',
+  '853','855','856','880','886','960','961','962','963','964','965','966',
+  '967','968','970','971','972','973','974','975','976','977','992','993',
+  '994','995','996','998'
 ]);
 
 const TWO_DIGIT_CCS = new Set([
@@ -451,11 +597,10 @@ const TWO_DIGIT_CCS = new Set([
   '95','98'
 ]);
 
-// Every country we carry metadata for has to be splittable here, or parsePhone
-// takes the wrong prefix and the registration token ends up computed over the
-// wrong national number — which the server answers by refusing the code. The
-// two lists above were maintained by hand and had already drifted, so the
-// country table itself gets the last word.
+// The country table only covers the places we carry carrier metadata for, which
+// is far fewer than the places that can register. Anything it names still has to
+// be splittable, so it is folded in — a no-op while the lists above are complete,
+// and a backstop if a code is ever added to the table and not to them.
 for (const cc of Object.keys(COUNTRY_META)) {
   if      (cc.length === 3) THREE_DIGIT_CCS.add(cc);
   else if (cc.length === 2) TWO_DIGIT_CCS.add(cc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.14.6",
+  "version": "5.14.8",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API and web ",
   "author": "Kunboruto20",
   "main": "index.js",