@zentrix/baileys 4.1.5

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeTcTokensFromIqResult = exports.buildTcTokenFromJid = exports.resolveIssuanceJid = exports.resolveTcTokenJid = exports.shouldSendNewTcToken = exports.isTcTokenExpired = exports.buildMergedTcTokenIndexWrite = exports.readTcTokenIndex = exports.TC_TOKEN_INDEX_KEY = void 0;
+const WABinary_1 = require("../WABinary");
+
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` — gates tctoken storage against
+ * malformed notifications. Works for both pre- and post-normalized JIDs.
+ */
+function isRegularUser(jid) {
+    if (!jid) return false;
+    const user = jid.split('@')[0] || '';
+    if (user === '0') return false; // PSA
+    if (BOT_PHONE_REGEX.test(user)) return false; // Bot by phone
+    if (isJidMetaAI(jid)) return false; // MetaAI
+    return !!(
+        isPnUser(jid) ||
+        isLidUser(jid) ||
+        isHostedPnUser(jid) ||
+        isHostedLidUser(jid) ||
+        jid.endsWith('@c.us')
+    );
+}
+
+// Re-use helpers from WABinary if available, otherwise inline
+function isPnUser(jid) { return !!(jid?.endsWith('@s.whatsapp.net')); }
+function isLidUser(jid) { return !!(jid?.endsWith('@lid')); }
+function isHostedPnUser(jid) { return !!(jid?.endsWith('@hosted')); }
+function isHostedLidUser(jid) { return !!(jid?.endsWith('@hosted.lid')); }
+function isJidMetaAI(jid) { return !!(jid?.endsWith('@bot')); }
+
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+
+/** Sentinel key holding a JSON array of tracked storage JIDs for cross-session pruning. */
+exports.TC_TOKEN_INDEX_KEY = '__index';
+
+async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [exports.TC_TOKEN_INDEX_KEY]);
+    const entry = data[exports.TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length) return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed)) return [];
+        return parsed.filter(j => typeof j === 'string' && j.length > 0 && j !== exports.TC_TOKEN_INDEX_KEY);
+    } catch {
+        return [];
+    }
+}
+exports.readTcTokenIndex = readTcTokenIndex;
+
+async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== exports.TC_TOKEN_INDEX_KEY) merged.add(jid);
+    }
+    return {
+        [exports.TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+exports.buildMergedTcTokenIndexWrite = buildMergedTcTokenIndexWrite;
+
+function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined) return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts)) return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+exports.isTcTokenExpired = isTcTokenExpired;
+
+function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined) return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+exports.shouldSendNewTcToken = shouldSendNewTcToken;
+
+async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid)) return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+exports.resolveTcTokenJid = resolveTcTokenJid;
+
+async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid)) return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid)) return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+exports.resolveIssuanceJid = resolveIssuanceJid;
+
+async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                const cleared =
+                    entry?.senderTimestamp !== undefined
+                        ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                        : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+
+        return baseContent;
+    } catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+exports.buildTcTokenFromJid = buildTcTokenFromJid;
+
+async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = (0, WABinary_1.getBinaryNodeChild)(result, 'tokens');
+    if (!tokensNode) return;
+
+    const tokenNodes = (0, WABinary_1.getBinaryNodeChildren)(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+
+        const rawJid = (0, WABinary_1.jidNormalizedUser)(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid)) continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        if (!incomingTs) continue;
+        if (existingTs > 0 && existingTs > incomingTs) continue;
+
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        if (onNewJidStored) onNewJidStored(storageJid);
+    }
+}
+exports.storeTcTokensFromIqResult = storeTcTokensFromIqResult;

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticationState } from '../Types';
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+export declare const useMultiFileAuthState: (folder: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+}>;
+ 

package/lib/Utils/use-multi-file-auth-state.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiFileAuthState = void 0;
+const async_mutex_1 = require("async-mutex");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const WAProto_1 = require("../../WAProto");
+const auth_utils_1 = require("./auth-utils");
+const generics_1 = require("./generics");
+const fileLocks = new Map();
+const getFileLock = (path) => {
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = new async_mutex_1.Mutex();
+        fileLocks.set(path, mutex);
+    }
+    return mutex;
+};
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+const useMultiFileAuthState = async (folder) => {
+    const writeData = async (data, file) => {
+        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        const mutex = getFileLock(filePath);
+        return mutex.acquire().then(async (release) => {
+            try {
+                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer));
+            }
+            finally {
+                release();
+            }
+        });
+    };
+    const readData = async (file) => {
+        try {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return await mutex.acquire().then(async (release) => {
+                try {
+                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
+                    return JSON.parse(data, generics_1.BufferJSON.reviver);
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return mutex.acquire().then(async (release) => {
+                try {
+                    await (0, promises_1.unlink)(filePath);
+                }
+                catch (_a) {
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch (_a) {
+        }
+    };
+    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    if (folderInfo) {
+        if (!folderInfo.isDirectory()) {
+            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
+        }
+    }
+    else {
+        await (0, promises_1.mkdir)(folder, { recursive: true });
+    }
+    const fixFileName = (file) => { var _a; return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-'); };
+    const creds = await readData('creds.json') || (0, auth_utils_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const file = `${category}-${id}.json`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
+    };
+};
+exports.useMultiFileAuthState = useMultiFileAuthState;

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,11 @@
+import { proto } from '../../WAProto';
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const generateMobileNode: (config: SocketConfig) => proto.IClientPayload;
+export declare const generateLoginNode: (userJid: string, config: SocketConfig) => proto.IClientPayload;
+export declare const generateRegistrationNode: ({ registrationId, signedPreKey, signedIdentityKey }: SignalCreds, config: SocketConfig) => proto.ClientPayload;
+export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, 'advSecretKey' | 'signedIdentityKey' | 'signalIdentities'>) => {
+    creds: Partial<AuthenticationCreds>;
+    reply: BinaryNode;
+}; 
+export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array;

package/lib/Utils/validate-connection.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = void 0;
+const boom_1 = require("@hapi/boom");
+const crypto_1 = require("crypto");
+const WAProto_1 = require("../../WAProto");
+const Defaults_1 = require("../Defaults");
+const WABinary_1 = require("../WABinary");
+const crypto_2 = require("./crypto");
+const generics_1 = require("./generics");
+const signal_1 = require("./signal");
+
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2],
+        },
+        platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        localeLanguageIso6391: 'en',
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode || 'US'
+    };
+};
+
+const PLATFORM_MAP = {
+    'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+};
+
+const getWebInfo = (config) => {
+    let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]] && config.browser[1] === 'Desktop') {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]];
+    }
+    return { webSubPlatform };
+};
+
+const getClientPayload = (config) => {
+    const payload = {
+        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config),
+    };
+    payload.webInfo = getWebInfo(config);
+    return payload;
+};
+
+const generateLoginNode = (userJid, config) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(userJid);
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        lidDbMigrated: false
+    };
+    return WAProto_1.proto.ClientPayload.fromObject(payload);
+};
+exports.generateLoginNode = generateLoginNode;
+
+const getPlatformType = (platform) => {
+    const platformType = platform.toUpperCase();
+    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.CHROME;
+};
+
+const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    const appVersionBuf = (0, crypto_1.createHash)('md5')
+        .update(config.version.join('.'))
+        .digest();
+
+    const companion = {
+        os: config.browser[0],
+        platformType: getPlatformType(config.browser[1]),
+        requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: {
+            primary: 10,
+            secondary: 15,
+            tertiary: 7
+        }
+    };
+
+    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
+
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: (0, generics_1.encodeBigEndian)(registrationId),
+            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature,
+        },
+    };
+    return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
+};
+exports.generateRegistrationNode = generateRegistrationNode;
+
+const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+    const msgId = stanza.attrs.id;
+    const pairSuccessNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-success');
+    const deviceIdentityNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device-identity');
+    const platformNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'platform');
+    const deviceNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device');
+    const businessNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'biz');
+
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new boom_1.Boom('Missing device-identity or device in pair success node', { data: stanza });
+    }
+
+    const bizName = businessNode?.attrs.name;
+    const jid = deviceNode.attrs.jid;
+    const lid = deviceNode.attrs.lid;
+
+    const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = Buffer.from([0x06, 0x05]);
+    }
+
+    const advSign = (0, crypto_2.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new boom_1.Boom('Invalid account signature');
+    }
+
+    const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details);
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+
+    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails);
+
+    const accountSignaturePrefix = deviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED 
+        ? Buffer.from([0x06, 0x05])
+        : Buffer.from([0x06, 0x00]);
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    
+    if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new boom_1.Boom('Failed to verify account signature');
+    }
+
+    const deviceMsg = Buffer.concat([
+        Buffer.from([0x06, 0x01]),
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg);
+
+    const identity = (0, signal_1.createSignalIdentity)(jid, accountSignatureKey);
+    const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
+
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: WABinary_1.S_WHATSAPP_NET,
+            type: 'result',
+            id: msgId,
+        },
+        content: [
+            {
+                tag: 'pair-device-sign',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-identity',
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        content: accountEnc
+                    }
+                ]
+            }
+        ]
+    };
+
+    const authUpdate = {
+        account,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [
+            ...(signalIdentities || []),
+            identity
+        ],
+        platform: platformNode?.attrs.name
+    };
+
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+exports.configureSuccessfulPairing = configureSuccessfulPairing;
+
+const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account };
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return WAProto_1.proto.ADVSignedDeviceIdentity
+        .encode(account)
+        .finish();
+};
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;

package/lib/WABinary/constants.d.ts

@@ -0,0 +1,30 @@
+export declare const TAGS: {
+    LIST_EMPTY: number
+    DICTIONARY_0: number
+    DICTIONARY_1: number
+    DICTIONARY_2: number
+    DICTIONARY_3: number
+    INTEROP_JID: number
+    FB_JID: number
+    AD_JID: number
+    LIST_8: number
+    LIST_16: number
+    JID_PAIR: number
+    HEX_8: number
+    BINARY_8: number
+    BINARY_20: number
+    BINARY_32: number
+    NIBBLE_8: number
+    PACKED_MAX: number
+}
+
+export declare const DOUBLE_BYTE_TOKENS: string[][]
+
+export declare const SINGLE_BYTE_TOKENS: (string | null)[]
+
+export declare const TOKEN_MAP: {
+    [token: string]: {
+        dict?: number
+        index: number
+    }
+}