@nexustechpro/baileys 2.0.5 → 2.0.6

package/WAProto/index.js

@@ -12,14 +12,18 @@ function longToString(value, unsigned) {
 	if (typeof value === "number") {
 		return String(value);
 	}
-	if (!$util.Long) {
-		return String(value);
+	// Fast path: convert Long {low, high} directly via native BigInt
+	// BigInt.toString() is a native C++ operation, much faster than Long's pure JS division loops
+	if (value && typeof value.low === "number" && typeof value.high === "number") {
+		const lo = BigInt(value.low >>> 0);
+		const hi = BigInt(value.high >>> 0);
+		const combined = (hi << 32n) | lo;
+		if (!unsigned && value.high < 0) {
+			return (combined - (1n << 64n)).toString();
+		}
+		return combined.toString();
 	}
-	const normalized = $util.Long.fromValue(value);
-	const prepared = unsigned && normalized && typeof normalized.toUnsigned === "function"
-		? normalized.toUnsigned()
-		: normalized;
-	return prepared.toString();
+	return String(value);
 }
 
 function longToNumber(value, unsigned) {
@@ -27,19 +31,19 @@ function longToNumber(value, unsigned) {
 		return value;
 	}
 	if (typeof value === "string") {
-		const numeric = Number(value);
-		return numeric;
-	}
-	if (!$util.Long) {
 		return Number(value);
 	}
-	const normalized = $util.Long.fromValue(value);
-	const prepared = unsigned && normalized && typeof normalized.toUnsigned === "function"
-		? normalized.toUnsigned()
-		: typeof normalized.toSigned === "function"
-			? normalized.toSigned()
-			: normalized;
-	return prepared.toNumber();
+	// Fast path: convert Long {low, high} directly via native BigInt
+	if (value && typeof value.low === "number" && typeof value.high === "number") {
+		const lo = BigInt(value.low >>> 0);
+		const hi = BigInt(value.high >>> 0);
+		const combined = (hi << 32n) | lo;
+		if (!unsigned && value.high < 0) {
+			return Number(combined - (1n << 64n));
+		}
+		return Number(combined);
+	}
+	return Number(value);
 }
 
 export const proto = $root.proto = (() => {

package/lib/Defaults/baileys-version.json

@@ -2,6 +2,6 @@
     "version": [
         2,
         3000,
-        1036200034
+        1040069233
     ]
 }

package/lib/Defaults/index.js

@@ -7,7 +7,7 @@ import logger from '../Utils/logger.js';
 const require = createRequire(import.meta.url);
 const PHONENUMBER_MCC = require('./phonenumber-mcc.json');
 export { PHONENUMBER_MCC };
-const version = [2, 3000, 1036200034];
+const version = [2, 3000, 1040069233];
 
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 
@@ -55,19 +55,20 @@ export const PROCESSABLE_HISTORY_TYPES = [
 ];
 export const MOBILE_ENDPOINT = 'g.whatsapp.net';
 export const MOBILE_PORT = 443;
-
-const WA_VERSION = '2.25.23.24';
-const WA_VERSION_HASH = createHash('md5').update(WA_VERSION).digest('hex');
-
+export const WA_VERSION = '2.2413.51'
+export const WA_VERSION_HASH = createHash('md5').update(WA_VERSION).digest('hex');
 export const MOBILE_TOKEN = Buffer.from('0a1mLfGUIBVrMKF1RdvLI5lkRBvof6vn0fD2QRSM' + WA_VERSION_HASH);
 export const MOBILE_REGISTRATION_ENDPOINT = 'https://v.whatsapp.net/v2';
 export const MOBILE_USERAGENT = `WhatsApp/${WA_VERSION} iOS/17.5.1 Device/Apple-iPhone_13`;
-
+export const GRAPHQL_ENDPOINT = 'https://graph.whatsapp.com/graphql'
+export const GRAPHQL_ACCESS_TOKEN = 'WA|1015890928915437|3201f239340c1c8ec6262a6dad04200e'
+export const GRAPHQL_BAN_STATUS_DOC_ID = '25573756098908502'
 export const REGISTRATION_PUBLIC_KEY = Buffer.from([
     5, 142, 140, 15, 116, 195, 235, 197, 215, 166, 134, 92, 108, 60, 132, 56, 86, 176, 97, 33, 204, 232, 234, 119, 77,
     34, 251, 111, 18, 37, 18, 48, 45,
 ]);
 
+
 export const PROTOCOL_VERSION = [5, 2];
 export const MOBILE_NOISE_HEADER = Buffer.concat([Buffer.from('WA'), Buffer.from(PROTOCOL_VERSION)]);
 

package/lib/Signal/libsignal.js

@@ -25,7 +25,7 @@ const jidToAddr = (jid) => {
 
 const jidToSenderKeyName = (group, user) => new SenderKeyName(group, jidToAddr(user))
 
-const v2Key = (addr) => `${addr}:v2` // v2 slot holds the actual serialized SessionRecord bytes
+const v2Key = (addr) => `${addr}:v2`
 
 // ─── Identity Extraction ──────────────────────────────────────────────────────
 
@@ -56,7 +56,6 @@ function extractIdentityFromPkmsg(ciphertext) {
 
 // ─── Buffer Utils ─────────────────────────────────────────────────────────────
 
-// universal deserializer — handles all shapes written by any previous version
 const toBuffer = (raw) => {
   if (!raw) return null
   if (raw instanceof Uint8Array) return raw
@@ -68,7 +67,6 @@ const toBuffer = (raw) => {
   return null
 }
 
-// detects old libsignal JS JSON format — not deserializable by whatsapp-rust-bridge
 const isOldJson = (raw) => {
   if (!raw || raw instanceof Uint8Array || Buffer.isBuffer(raw)) return false
   if (typeof raw === 'object') return 'version' in raw || '_sessions' in raw
@@ -97,6 +95,28 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
       return txn(() => new GroupSessionBuilder(storage).process(senderName, senderMsg), item.groupId)
     },
 
+    async encryptGroupMessage({ group, meId, data }) {
+      const senderName = jidToSenderKeyName(group, meId)
+      const skdm = await new GroupSessionBuilder(storage).create(senderName)
+      const plaintext = data instanceof Uint8Array && data.constructor === Uint8Array
+        ? data
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+      const ciphertext = await new GroupCipher(storage, group, jidToAddr(meId)).encrypt(plaintext)
+      return { ciphertext, senderKeyDistributionMessage: skdm.serialize() }
+    },
+
+    async getSenderKeyDistributionMessage({ group, meId }) {
+      const senderName = jidToSenderKeyName(group, meId)
+      const skdm = await new GroupSessionBuilder(storage).create(senderName)
+      return skdm.serialize()
+    },
+
+    async hasSenderKey({ group, meId }) {
+      const name = jidToSenderKeyName(group, meId).toString()
+      const { [name]: key } = await parsedKeys.get('sender-key', [name])
+      return !!toBuffer(key)
+    },
+
     async decryptMessage({ jid, type, ciphertext }) {
       const addr = jidToAddr(jid)
       const cipher = new SessionCipher(storage, addr)
@@ -107,15 +127,14 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
           if (changed) logger?.info?.({ jid }, '[Signal] Identity key changed, session cleared')
         }
       }
-      const doDecrypt = (c, t) => {
-        if (t === 'pkmsg') return c.decryptPreKeyWhisperMessage(ciphertext)
-        if (t === 'msg') return c.decryptWhisperMessage(ciphertext)
-        throw new Error(`Unknown type: ${t}`)
-      }
       try {
-        return await txn(() => doDecrypt(cipher, type), jid)
+        return await txn(() => {
+          if (type === 'pkmsg') return cipher.decryptPreKeyWhisperMessage(ciphertext)
+          if (type === 'msg') return cipher.decryptWhisperMessage(ciphertext)
+          throw new Error(`Unknown type: ${type}`)
+        }, jid)
       } catch (e) {
-        if (e?.message?.includes('DuplicatedMessage')) { logger?.debug?.({ jid }, '[Signal] Duplicate message ignored — offline replay'); return null }
+        if (e?.message?.includes('DuplicatedMessage')) { logger?.debug?.({ jid }, '[Signal] Duplicate message ignored'); return null }
         throw e
       }
     },
@@ -127,14 +146,6 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
       }, jid)
     },
 
-    encryptGroupMessage({ group, meId, data }) {
-      return txn(async () => {
-        const senderName = jidToSenderKeyName(group, meId)
-        const senderKeyDistributionMessage = await new GroupSessionBuilder(storage).create(senderName)
-        return { ciphertext: await new GroupCipher(storage, group, jidToAddr(meId)).encrypt(data), senderKeyDistributionMessage: senderKeyDistributionMessage.serialize() }
-      }, group)
-    },
-
     injectE2ESession({ jid, session }) {
       return txn(() => new SessionBuilder(storage, jidToAddr(jid)).processPreKeyBundle(session), jid)
     },
@@ -147,7 +158,7 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
       try {
         const addr = jidToAddr(jid).toString()
         const batch = await migrateIndexKey(parsedKeys, 'session')
-        const raw = toBuffer(batch[v2Key(addr)]) || toBuffer(batch[addr]) // v2 slot first, fall back to plain
+        const raw = toBuffer(batch[v2Key(addr)]) || toBuffer(batch[addr])
         if (!raw || isOldJson(raw)) return { exists: false, reason: 'no session' }
         const sess = SessionRecord.deserialize(raw)
         if (!sess.haveOpenSession()) return { exists: false, reason: 'no open session' }
@@ -160,7 +171,7 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
       return txn(async () => {
         const batch = await migrateIndexKey(parsedKeys, 'session')
         for (const jid of jids) { const addr = jidToAddr(jid).toString(); delete batch[addr]; delete batch[v2Key(addr)] }
-        await parsedKeys.set({ session: { 'index': batch } })
+        await parsedKeys.set({ session: { index: batch } })
       }, `del-${jids.length}`)
     },
 
@@ -185,55 +196,44 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
         for (const { jid } of deviceJids) {
           const pnAddr = jidToAddr(jid).toString()
           const lidAddr = jidToAddr(transferDevice(jid, toJid)).toString()
-          const raw = toBuffer(updated[v2Key(pnAddr)]) || toBuffer(updated[pnAddr]) // prefer v2 slot
+          const raw = toBuffer(updated[v2Key(pnAddr)]) || toBuffer(updated[pnAddr])
           if (!raw || isOldJson(raw)) continue
           const sess = SessionRecord.deserialize(raw)
           if (!sess.haveOpenSession()) continue
           updated[v2Key(lidAddr)] = sess.serialize()
-          updated[lidAddr] = { version: 'v1', _sessions: {} } // plain slot marker for compat
+          updated[lidAddr] = { version: 'v1', _sessions: {} }
           delete updated[v2Key(pnAddr)]
           delete updated[pnAddr]
           migrated++
           migratedCache.set(`${user}.${jidDecode(jid).device || 0}`, true)
         }
-        if (migrated > 0) await parsedKeys.set({ session: { 'index': updated } })
+        if (migrated > 0) await parsedKeys.set({ session: { index: updated } })
         return { migrated, skipped: deviceJids.length - migrated, total: deviceJids.length }
       }, `migrate-${deviceJids.length}`)
     },
 
-    // Batch-migrate all PN-addressed sessions to their LID equivalents.
-    // Called once on CB:success before offline messages are processed — one read, one remap, one write.
     async migrateAllPNSessionsToLID() {
       return txn(async () => {
         const sessionBatch = await migrateIndexKey(parsedKeys, 'session')
         const sessionKeys = Object.keys(sessionBatch)
         if (!sessionKeys.length) return 0
-
-        // collect plain (non-v2) PN-domain keys only — v2 slots are handled via their plain counterpart
         const pnAddrs = sessionKeys.filter(addr => {
-          if (addr.endsWith(':v2')) return false
-          if (!addr.includes('.')) return false
-          const [deviceId] = addr.split('.')
-          const [, dt] = deviceId.split('_')
+          if (addr.endsWith(':v2') || !addr.includes('.')) return false
+          const [, dt] = addr.split('.')[0].split('_')
           const domainType = parseInt(dt || '0')
           return domainType === WAJIDDomains.WHATSAPP || domainType === WAJIDDomains.HOSTED
         })
         if (!pnAddrs.length) return 0
-
-        // batch-fetch LID mappings directly from key store — same format storeLIDPNMappings writes
         const pnUserSet = new Set(pnAddrs.map(addr => addr.split('.')[0].split('_')[0]))
         const stored = await parsedKeys.get('lid-mapping', [...pnUserSet])
-
         const pnToLidUserMap = new Map()
         for (const pnUser of pnUserSet) {
           const lidUser = stored[pnUser]
           if (lidUser && typeof lidUser === 'string') pnToLidUserMap.set(pnUser, lidUser)
         }
         if (!pnToLidUserMap.size) return 0
-
         let migrated = 0
         const updated = { ...sessionBatch }
-
         for (const addr of pnAddrs) {
           const [deviceId, device] = addr.split('.')
           const [user, dt] = deviceId.split('_')
@@ -242,25 +242,34 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
           if (!lidUser) continue
           const lidDomainType = domainType === WAJIDDomains.HOSTED ? WAJIDDomains.HOSTED_LID : WAJIDDomains.LID
           const lidAddr = `${lidUser}_${lidDomainType}.${device}`
-          if (updated[v2Key(lidAddr)]) continue // LID session already exists, skip
-          const raw = toBuffer(updated[v2Key(addr)]) || toBuffer(updated[addr]) // prefer v2 slot
+          if (updated[v2Key(lidAddr)]) continue
+          const raw = toBuffer(updated[v2Key(addr)]) || toBuffer(updated[addr])
           if (!raw || isOldJson(raw)) continue
           const sess = SessionRecord.deserialize(raw)
           if (!sess.haveOpenSession()) continue
           updated[v2Key(lidAddr)] = sess.serialize()
-          updated[lidAddr] = { version: 'v1', _sessions: {} } // plain slot marker for compat
+          updated[lidAddr] = { version: 'v1', _sessions: {} }
           delete updated[v2Key(addr)]
           delete updated[addr]
           migrated++
           migratedCache.set(`${user}.${device}`, true)
         }
-
         if (migrated > 0) {
-          await parsedKeys.set({ session: { 'index': updated } })
+          await parsedKeys.set({ session: { index: updated } })
           logger?.info?.({ migrated, totalPN: pnAddrs.length, mappingsFound: pnToLidUserMap.size }, '[Signal] Batch-migrated PN sessions to LID on connect')
         }
         return migrated
       }, 'migrate-all-pn-to-lid')
+    },
+
+    deleteSenderKey(group, authorJid) {
+      const senderName = jidToSenderKeyName(group, authorJid).toString()
+      return parsedKeys.set({ 'sender-key': { [senderName]: null } })
+    },
+
+    close() {
+      migratedCache.clear()
+      lidMapping.close?.()
     }
   }
 }
@@ -268,7 +277,7 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 // ─── Storage Adapter ──────────────────────────────────────────────────────────
 
 function signalStorage({ creds, keys }, lidMapping, logger) {
-  const lidCache = new LRUCache({ max: 500, ttl: 5 * 60 * 1000 }) // cache PN→LID resolutions for 5 min
+  const lidCache = new LRUCache({ max: 500, ttl: 5 * 60 * 1000 })
 
   const resolveLID = async (id) => {
     if (!id.includes('.')) return id
@@ -286,7 +295,7 @@ function signalStorage({ creds, keys }, lidMapping, logger) {
   }
 
   const getIndex = () => migrateIndexKey(keys, 'session')
-  const setIndex = (batch) => keys.set({ session: { 'index': batch } })
+  const setIndex = (batch) => keys.set({ session: { index: batch } })
 
   return {
     loadSession: async (id) => {
@@ -300,7 +309,7 @@ function signalStorage({ creds, keys }, lidMapping, logger) {
           if (buf) return buf
         }
         const plain = batch[addr]
-        if (!plain || isOldJson(plain)) { // old JS JSON format — not usable by rust bridge
+        if (!plain || isOldJson(plain)) {
           if (plain) logger?.debug?.(`[Signal] Old JSON session for ${addr}, will fresh handshake`)
           return null
         }
@@ -311,8 +320,8 @@ function signalStorage({ creds, keys }, lidMapping, logger) {
     storeSession: async (id, session) => {
       const addr = await resolveLID(id)
       const batch = await getIndex()
-      batch[v2Key(addr)] = session.serialize() // always write to v2 slot
-      batch[addr] = { version: 'v1', _sessions: {} } // plain slot marker so old code sees something
+      batch[v2Key(addr)] = session.serialize()
+      batch[addr] = { version: 'v1', _sessions: {} }
       await setIndex(batch)
     },
 
@@ -352,7 +361,11 @@ function signalStorage({ creds, keys }, lidMapping, logger) {
 
     loadSignedPreKey: () => {
       const { signedPreKey: key } = creds
-      return { keyId: key.keyId, keyPair: { pubKey: new Uint8Array(Buffer.from(key.keyPair.public)), privKey: new Uint8Array(Buffer.from(key.keyPair.private)) }, signature: new Uint8Array(Buffer.from(key.signature)) }
+      return {
+        keyId: key.keyId,
+        keyPair: { pubKey: new Uint8Array(Buffer.from(key.keyPair.public)), privKey: new Uint8Array(Buffer.from(key.keyPair.private)) },
+        signature: new Uint8Array(Buffer.from(key.signature))
+      }
     },
 
     loadSenderKey: async (keyId) => {
@@ -365,15 +378,17 @@ function signalStorage({ creds, keys }, lidMapping, logger) {
 
     storeSenderKey: async (keyId, record) => {
       const id = keyId.toString()
-      const bytes = record instanceof Uint8Array ? record : Buffer.isBuffer(record) ? record : record.serialize()
-      await keys.set({ 'sender-key': { [id]: bytes } })
+      await keys.set({ 'sender-key': { [id]: Buffer.from(record) } })
     },
 
     getOurRegistrationId: () => creds.registrationId,
 
     getOurIdentity: () => {
       const { signedIdentityKey } = creds
-      return { pubKey: new Uint8Array(generateSignalPubKey(Buffer.from(signedIdentityKey.public))), privKey: new Uint8Array(Buffer.from(signedIdentityKey.private)) }
+      return {
+        pubKey: new Uint8Array(generateSignalPubKey(Buffer.from(signedIdentityKey.public))),
+        privKey: new Uint8Array(Buffer.from(signedIdentityKey.private))
+      }
     }
   }
 }

package/lib/Socket/chats.js

@@ -1,7 +1,7 @@
 import NodeCache from '@cacheable/node-cache'
 import { Boom } from '@hapi/boom'
 import { proto } from '../../WAProto/index.js'
-import { DEFAULT_CACHE_TTLS, PROCESSABLE_HISTORY_TYPES } from '../Defaults/index.js'
+import { DEFAULT_CACHE_TTLS, PROCESSABLE_HISTORY_TYPES, PHONENUMBER_MCC, MOBILE_TOKEN, MOBILE_USERAGENT, MOBILE_REGISTRATION_ENDPOINT } from '../Defaults/index.js'
 import { ALL_WA_PATCH_NAMES } from '../Types/index.js'
 import { SyncState } from '../Types/State.js'
 import {
@@ -25,7 +25,8 @@ import {
     jidDecode,
     jidNormalizedUser,
     reduceBinaryNodeToDictionary,
-    S_WHATSAPP_NET
+    S_WHATSAPP_NET,
+    VIOLATION_TYPES
 } from '../WABinary/index.js'
 import { USyncQuery, USyncUser } from '../WAUSync/index.js'
 import { makeSocket } from './socket.js'
@@ -217,60 +218,6 @@ export const makeChatsSocket = (config) => {
         )
     }
 
-    const checkStatusWA = async (phoneNumber) => {
-        if (!phoneNumber) throw new Error('enter number')
-
-        let resultData = { isBanned: false, isNeedOfficialWa: false, number: phoneNumber }
-
-        let formattedNumber = phoneNumber.startsWith('+') ? phoneNumber : '+' + phoneNumber
-
-        const { parsePhoneNumber } = await import('libphonenumber-js')
-        const parsedNumber = parsePhoneNumber(formattedNumber)
-        const countryCode = parsedNumber.countryCallingCode
-        const nationalNumber = parsedNumber.nationalNumber
-
-        try {
-            const { useMultiFileAuthState, fetchLatestBaileysVersion, Browsers } = await import('../Utils/index.js')
-            const { state } = await useMultiFileAuthState('.npm')
-            const { version } = await fetchLatestBaileysVersion()
-            const { makeWASocket } = await import('../Socket/index.js')
-            const pino = (await import('pino')).default
-
-            const tempSock = makeWASocket({
-                version,
-                auth: state,
-                browser: Browsers.ubuntu('Chrome'),
-                logger: pino({ level: 'silent' }),
-                printQRInTerminal: false
-            })
-
-            await tempSock.requestRegistrationCode({
-                phoneNumber: formattedNumber,
-                phoneNumberCountryCode: countryCode,
-                phoneNumberNationalNumber: nationalNumber,
-                phoneNumberMobileCountryCode: '510',
-                phoneNumberMobileNetworkCode: '10',
-                method: 'sms'
-            })
-
-            if (tempSock.ws) tempSock.ws.close()
-            return JSON.stringify(resultData, null, 2)
-        } catch (err) {
-            if (err?.appeal_token) {
-                resultData.isBanned = true
-                resultData.data = {
-                    violation_type: err.violation_type || null,
-                    in_app_ban_appeal: err.in_app_ban_appeal || null,
-                    appeal_token: err.appeal_token || null
-                }
-            } else if (err?.custom_block_screen || err?.reason === 'blocked') {
-                resultData.isNeedOfficialWa = true
-            }
-            return JSON.stringify(resultData, null, 2)
-        }
-    }
-
-
     // ─── Profile ─────────────────────────────────────────────────────────────────
 
     const updateProfilePicture = async (jid, content) => {
@@ -906,4 +853,64 @@ export const makeChatsSocket = (config) => {
         addOrEditQuickReply,
         removeQuickReply
     }
-}
+}
+export const checkStatusWA = async (phoneNumber) => {
+    if (!phoneNumber) throw new Error('Please provide a phone number')
+
+    const formattedNumber = (() => {
+        let num = phoneNumber
+        if (num.includes('@')) num = num.split('@')[0]
+        if (num.includes(':')) num = num.split(':')[0]
+        if (!num.startsWith('+')) num = '+' + num
+        return num
+    })()
+
+    const { parsePhoneNumberWithError } = await import('libphonenumber-js')
+    const { countryCallingCode: countryCode, nationalNumber } = parsePhoneNumberWithError(formattedNumber)
+    const { mobileRegisterExists, getBanDetails } = await import('./registration.js')
+    const { initAuthCreds } = await import('../Utils/index.js')
+
+    const state = {
+        creds: initAuthCreds(),
+        keys: {
+            get: async () => ({}),
+            set: async () => { },
+            transaction: async (fn) => fn(),
+        }
+    }
+
+    const build = (status, isBanned, isNeedOfficialWa, banInfo = null) => ({
+        number: formattedNumber, status, isBanned, isNeedOfficialWa, banInfo
+    })
+
+    try {
+        await mobileRegisterExists({
+            ...state.creds,
+            phoneNumberCountryCode: countryCode,
+            phoneNumberNationalNumber: nationalNumber,
+        })
+        return build('active', false, false)
+    } catch (err) {
+        if (err?.appeal_token) {
+            const banDetails = await getBanDetails(err.appeal_token)
+            const appealStatus = banDetails?.status || null
+            const banType = appealStatus === 'BANNED' ? 'permanent' : 'temporary'
+
+            return build('banned', true, false, {
+                banType,
+                violationType: err.violation_type || null,
+                violationReason: err.violation_type ? `Type ${err.violation_type}` : 'Unknown',
+                canAppeal: banType !== 'permanent', // ✅ temporary = can appeal, permanent = cannot
+                appealToken: err.appeal_token,
+                banTime: banDetails?.ban_time || null,
+                banDate: banDetails?.ban_time ? new Date(banDetails.ban_time * 1000).toISOString() : null,
+                appealStatus,
+                appealCreatedAt: banDetails?.appeal_creation_time ? new Date(banDetails.appeal_creation_time * 1000).toISOString() : null,
+            })
+        }
+        if (err?.custom_block_screen) return build('blocked', false, true)
+        if (err?.reason === 'incorrect') return build('active', false, false)
+        if (err?.reason === 'temporarily_unavailable') return build('rate_limited', false, false)
+        return build('error', false, false)
+    }
+}

package/lib/Socket/index.js

@@ -1,6 +1,5 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeRegistrationSocket } from './registration.js';
-import NexusHandler from './nexus-handler.js';
 
 // export the last socket layer
 const makeWASocket = (config) => {
@@ -17,7 +16,7 @@ const makeWASocket = (config) => {
 
     return makeRegistrationSocket(newConfig);
 };
-
-export { NexusHandler };
+export * from './chats.js'
+export * from './nexus-handler.js'
 export { makeWASocket };
 export default makeWASocket;