whalibmob 5.19.3 → 5.19.4

package/lib/fcm.js

@@ -300,7 +300,30 @@ function parseDurationSeconds(text) {
   return m ? parseInt(m[1], 10) : 0;
 }
 
-async function register3(config, session) {
+// register3 answers a fresh android id with Error=PHONE_REGISTRATION_ERROR far
+// more often than not: Google will not register a device id the same second it
+// minted it, and a real phone's id is always days old by the time it asks. The
+// id has to age. A short backoff between tries is usually enough, and the same
+// id is reused across them precisely so it ages rather than being replaced.
+//
+// These are the errors worth trying again; anything else is a settled no.
+//   PHONE_REGISTRATION_ERROR   the common transient one — the id is too new
+//   SERVICE_NOT_AVAILABLE      Google-side hiccup
+//   INTERNAL_SERVER_ERROR      the same, phrased differently
+//   AUTHENTICATION_FAILED      the AidLogin is stale; needs a fresh checkin
+const REGISTER3_RETRYABLE = new Set([
+  'PHONE_REGISTRATION_ERROR', 'SERVICE_NOT_AVAILABLE', 'INTERNAL_SERVER_ERROR'
+]);
+
+const REGISTER3_MAX_ATTEMPTS = 4;
+// Waits before attempts 2, 3 and 4. Growing, so the id gets progressively more
+// time to settle without dragging registration out — the whole budget is ~12s,
+// well under one SMS round-trip.
+const REGISTER3_BACKOFF_MS = [1500, 4000, 6500];
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+function buildRegister3Body(config, session) {
   const form = {
     app:           config.packageName,
     sender:        config.senderId,
@@ -321,35 +344,53 @@ async function register3(config, session) {
     'X-Goog-Firebase-Installations-Auth': session.fisAuthToken,
     'X-firebase-app-name-hash': ''
   };
-
-  const body = Buffer.from(
+  return Buffer.from(
     Object.keys(form)
       .map(k => encodeURIComponent(k) + '=' + encodeURIComponent(form[k]))
       .join('&'),
     'utf8'
   );
+}
 
-  const res = await httpPost(REGISTER_URL, body, {
+// One attempt. Never throws for an answer Google actually sent — a token, an
+// Error= line and a 5xx are all outcomes, classified so the caller can decide
+// whether to try again. A network reject still propagates.
+//
+// Returns one of:
+//   { token }                              success
+//   { error, retryable, needsCheckin }     a refusal
+async function register3Once(config, session) {
+  const body = buildRegister3Body(config, session);
+  const res  = await httpPost(REGISTER_URL, body, {
     'Authorization': 'AidLogin ' + session.androidId + ':' + session.securityToken,
     'Content-Type':  'application/x-www-form-urlencoded',
     'User-Agent':    'Android-GCM/1.5 (generic LRX22C)',
     'app':           config.packageName
   });
+
+  if (res.status >= 500) {
+    return { error: 'HTTP ' + res.status, retryable: true, needsCheckin: false };
+  }
   if (res.status < 200 || res.status >= 300) {
-    throw new Error('register3 HTTP ' + res.status + ': ' + res.body.toString('utf8').slice(0, 200));
+    return { error: 'HTTP ' + res.status + ': ' + res.body.toString('utf8').slice(0, 120),
+             retryable: false, needsCheckin: false };
   }
 
-  // The answer is a flat key=value list; anything other than a token line is
-  // an error Google chose to report with a 200.
+  // A flat key=value list. A token line is success; an Error= line names the
+  // reason; anything else is treated as an unrecognised refusal.
   const text = res.body.toString('utf8').trim();
   for (const line of text.split('\n')) {
     const eq = line.indexOf('=');
-    if (eq > 0 && line.slice(0, eq).trim() === 'token') {
-      const token = line.slice(eq + 1).trim();
-      if (token) return token;
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    const val = line.slice(eq + 1).trim();
+    if (key === 'token' && val) return { token: val };
+    if (key === 'Error') {
+      const needsCheckin = val === 'AUTHENTICATION_FAILED';
+      return { error: val, retryable: REGISTER3_RETRYABLE.has(val) || needsCheckin, needsCheckin };
     }
   }
-  throw new Error('register3 returned no token: ' + text.slice(0, 200));
+  return { error: text.slice(0, 120) || 'empty response', retryable: false, needsCheckin: false };
 }
 
 // ─── public entry point ──────────────────────────────────────────────────────
@@ -401,32 +442,70 @@ async function getPushToken(store, device) {
       const ids = await checkin();
       androidId     = ids.androidId;
       securityToken = ids.securityToken;
+      // Persist the identity the moment it exists, so a failure in a later step
+      // still leaves the aged android id behind for the next attempt rather than
+      // throwing it away and minting a second one.
+      store.fcm = Object.assign({}, store.fcm, { androidId, securityToken });
     }
 
     _whaDbg('[DBG] FCM step 2/3 FIS install (' + config.packageName + ')');
-    const fis = await fisInstall(config, prev.fid);
+    let fis = await fisInstall(config, prev.fid);
 
     _whaDbg('[DBG] FCM step 3/3 register3');
-    const token = await register3(config, {
-      androidId, securityToken,
-      fid:           fis.fid,
-      fisAuthToken:  fis.authToken
-    });
+    let token = null;
+    let checkinRedone = false;
+
+    for (let attempt = 1; attempt <= REGISTER3_MAX_ATTEMPTS; attempt++) {
+      const result = await register3Once(config, { androidId, securityToken, fid: fis.fid, fisAuthToken: fis.authToken });
+
+      if (result.token) { token = result.token; break; }
+
+      const last = attempt === REGISTER3_MAX_ATTEMPTS;
+      _whaDbg('[DBG] FCM register3 attempt ' + attempt + '/' + REGISTER3_MAX_ATTEMPTS +
+        ' → ' + result.error + (result.retryable && !last ? ' (retrying)' : ''));
+
+      if (!result.retryable || last) break;
+
+      // A stale AidLogin is not fixed by waiting: the android id itself is no
+      // longer accepted, so mint a fresh one — but only once, so a server that
+      // keeps saying this cannot spin us forever.
+      if (result.needsCheckin && !checkinRedone) {
+        checkinRedone = true;
+        _whaDbg('[DBG] FCM re-running checkin after AUTHENTICATION_FAILED');
+        const ids = await checkin();
+        androidId     = ids.androidId;
+        securityToken = ids.securityToken;
+        // The FIS install is bound to nothing device-specific, but refreshing
+        // it alongside a new id keeps the pair consistent.
+        fis = await fisInstall(config, fis.fid);
+      }
+
+      await sleep(REGISTER3_BACKOFF_MS[Math.min(attempt - 1, REGISTER3_BACKOFF_MS.length - 1)]);
+    }
 
-    store.fcm = {
+    // Persist the Firebase identity even when no token came back. The android id
+    // is the valuable part — reused on the next registration attempt, by which
+    // time it has aged and register3 is far more likely to accept it. This is
+    // what turns a first-run PHONE_REGISTRATION_ERROR into a second-run success.
+    store.fcm = Object.assign({}, store.fcm, {
       androidId, securityToken,
       fid:             fis.fid,
       fisAuthToken:    fis.authToken,
       fisRefreshToken: fis.refreshToken,
       fisExpiresAt:    fis.expiresAt,
-      token
-    };
-    _whaDbg('[DBG] FCM push token acquired, length=' + token.length);
-    return token;
+      token:           token || (store.fcm && store.fcm.token) || null
+    });
+
+    if (token) {
+      _whaDbg('[DBG] FCM push token acquired, length=' + token.length);
+      return token;
+    }
+    _whaDbg('[DBG] FCM push token unavailable after ' + REGISTER3_MAX_ATTEMPTS +
+      ' attempts — registering without one (android id kept for next time)');
+    return null;
   } catch (err) {
-    // Keep whatever identity was established: a checkin that succeeded before a
-    // later step failed is worth carrying into the next attempt rather than
-    // minting a second android id.
+    // A checkin that succeeded before a later step threw has already written
+    // its android id to store.fcm above, so it survives into the next attempt.
     _whaDbg('[DBG] FCM push token unavailable: ' + (err && err.message) +
       ' — registering without one');
     return null;
@@ -441,5 +520,7 @@ module.exports = {
   encodeCheckinRequest,
   decodeCheckinResponse,
   generateFid,
-  parseDurationSeconds
+  parseDurationSeconds,
+  register3Once,
+  REGISTER3_MAX_ATTEMPTS
 };

package/package.json

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