@badzz88/baileys 8.4.6 → 8.4.9

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

@@ -1,163 +0,0 @@
-import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
-// Same phone-number pattern as WABinary's isJidBot, applied against the user
-// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
-const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
-/**
- * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
- * storage against malformed notifications — WA Web filters server-side but we
- * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
- * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
- */
-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 pattern
-    if (isJidMetaAI(jid))
-        return false; // MetaAI (@bot server)
-    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
-}
-const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
-const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
-/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
-export const TC_TOKEN_INDEX_KEY = '__index';
-/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
-export async function readTcTokenIndex(keys) {
-    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
-    const entry = data[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 !== TC_TOKEN_INDEX_KEY);
-    }
-    catch {
-        return [];
-    }
-}
-/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
-export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
-    const persisted = await readTcTokenIndex(keys);
-    const merged = new Set(persisted);
-    for (const jid of addedJids) {
-        if (jid && jid !== TC_TOKEN_INDEX_KEY)
-            merged.add(jid);
-    }
-    return {
-        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
-    };
-}
-// WA Web has separate sender/receiver AB props for these but they're identical today
-export 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;
-}
-export 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;
-}
-/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
-export async function resolveTcTokenJid(jid, getLIDForPN) {
-    if (isLidUser(jid))
-        return jid;
-    const lid = await getLIDForPN(jid);
-    return lid ?? jid;
-}
-/** Resolve target JID for issuing privacy token based on AB prop 14303 */
-export 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;
-}
-export 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) {
-                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
-                // after we drop the unusable peer token. Only wipe the record entirely when
-                // there's nothing worth keeping.
-                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;
-    }
-}
-export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
-    const tokensNode = getBinaryNodeChild(result, 'tokens');
-    if (!tokensNode)
-        return;
-    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
-    for (const tokenNode of tokenNodes) {
-        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
-            continue;
-        }
-        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
-        const rawJid = 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;
-        // timestamp-less tokens would be immediately expired
-        if (!incomingTs)
-            continue;
-        if (existingTs > 0 && existingTs > incomingTs)
-            continue;
-        await keys.set({
-            tctoken: {
-                [storageJid]: {
-                    ...existingEntry,
-                    token: Buffer.from(tokenNode.content),
-                    timestamp: tokenNode.attrs.t
-                }
-            }
-        });
-        onNewJidStored?.(storageJid);
-    }
-}
-//# sourceMappingURL=tc-token-utils.js.map

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

@@ -1,121 +0,0 @@
-import { Mutex } from 'async-mutex';
-import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { proto } from '../../WAProto/index.js';
-import { initAuthCreds } from './auth-utils.js';
-import { BufferJSON } from './generics.js';
-// We need to lock files due to the fact that we are using async functions to read and write files
-// https://github.com/WhiskeySockets/Baileys/issues/794
-// https://github.com/nodejs/node/issues/26338
-// Use a Map to store mutexes for each file path
-const fileLocks = new Map();
-// Get or create a mutex for a specific file path
-const getFileLock = (path) => {
-    let mutex = fileLocks.get(path);
-    if (!mutex) {
-        mutex = new 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
- * */
-export const useMultiFileAuthState = async (folder) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const writeData = async (data, file) => {
-        const filePath = join(folder, fixFileName(file));
-        const mutex = getFileLock(filePath);
-        return mutex.acquire().then(async (release) => {
-            try {
-                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
-            }
-            finally {
-                release();
-            }
-        });
-    };
-    const readData = async (file) => {
-        try {
-            const filePath = join(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return await mutex.acquire().then(async (release) => {
-                try {
-                    const data = await readFile(filePath, { encoding: 'utf-8' });
-                    return JSON.parse(data, BufferJSON.reviver);
-                }
-                finally {
-                    release();
-                }
-            });
-        }
-        catch (error) {
-            return null;
-        }
-    };
-    const removeData = async (file) => {
-        try {
-            const filePath = join(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return mutex.acquire().then(async (release) => {
-                try {
-                    await unlink(filePath);
-                }
-                catch {
-                }
-                finally {
-                    release();
-                }
-            });
-        }
-        catch { }
-    };
-    const folderInfo = await 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 mkdir(folder, { recursive: true });
-    }
-    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
-    const creds = (await readData('creds.json')) || 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 = 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');
-        }
-    };
-};
-//# sourceMappingURL=use-multi-file-auth-state.js.map

package/lib/Utils/validate-connection.js

@@ -1,204 +0,0 @@
-import { Boom } from '@hapi/boom';
-import { createHash } from 'crypto';
-import { proto } from '../../WAProto/index.js';
-import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX } from '../Defaults/index.js';
-import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { Curve, hmacSign } from './crypto.js';
-import { encodeBigEndian } from './generics.js';
-import { createSignalIdentity } from './signal.js';
-const getUserAgent = (config) => {
-    return {
-        appVersion: {
-            primary: config.version[0],
-            secondary: config.version[1],
-            tertiary: config.version[2]
-        },
-        platform: proto.ClientPayload.UserAgent.Platform.MACOS,
-        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-        osVersion: '0.1',
-        device: 'Desktop',
-        osBuildNumber: '0.1',
-        localeLanguageIso6391: 'en',
-        mnc: '000',
-        mcc: '000',
-        localeCountryIso31661Alpha2: config.countryCode
-    };
-};
-const PLATFORM_MAP = {
-    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
-};
-const getWebInfo = (config) => {
-    let webSubPlatform = 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: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: getUserAgent(config)
-    };
-    payload.webInfo = getWebInfo(config);
-    if (config.pushName) {
-        payload.pushName = config.pushName;
-    }
-    return payload;
-};
-export const generateLoginNode = (userJid, config) => {
-    const { user, device } = jidDecode(userJid);
-    const payload = {
-        ...getClientPayload(config),
-        passive: true,
-        pull: true,
-        username: +user,
-        device: device,
-        // TODO: investigate (hard set as false atm)
-        lidDbMigrated: false
-    };
-    return proto.ClientPayload.fromObject(payload);
-};
-const getPlatformType = (platform) => {
-    const platformType = platform.toUpperCase();
-    return (proto.DeviceProps.PlatformType[platformType] ||
-        proto.DeviceProps.PlatformType.CHROME);
-};
-export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
-    // the app version needs to be md5 hashed
-    // and passed in
-    const appVersionBuf = createHash('md5')
-        .update(config.version.join('.')) // join as string
-        .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 = proto.DeviceProps.encode(companion).finish();
-    const registerPayload = {
-        ...getClientPayload(config),
-        passive: false,
-        pull: false,
-        devicePairingData: {
-            buildHash: appVersionBuf,
-            deviceProps: companionProto,
-            eRegid: encodeBigEndian(registrationId),
-            eKeytype: KEY_BUNDLE_TYPE,
-            eIdent: signedIdentityKey.public,
-            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
-            eSkeyVal: signedPreKey.keyPair.public,
-            eSkeySig: signedPreKey.signature
-        }
-    };
-    return proto.ClientPayload.fromObject(registerPayload);
-};
-export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
-    const msgId = stanza.attrs.id;
-    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
-    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
-    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
-    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device');
-    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz');
-    if (!deviceIdentityNode || !deviceNode) {
-        throw new 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 } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-    let hmacPrefix = Buffer.from([]);
-    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
-        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
-    }
-    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
-    if (Buffer.compare(hmac, advSign) !== 0) {
-        throw new Boom('Invalid account signature');
-    }
-    const account = proto.ADVSignedDeviceIdentity.decode(details);
-    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
-    const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
-    const accountSignaturePrefix = deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
-        ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
-        : WA_ADV_ACCOUNT_SIG_PREFIX;
-    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
-    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
-        throw new Boom('Failed to verify account signature');
-    }
-    const deviceMsg = Buffer.concat([
-        WA_ADV_DEVICE_SIG_PREFIX,
-        deviceDetails,
-        signedIdentityKey.public,
-        accountSignatureKey
-    ]);
-    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
-    const identity = createSignalIdentity(lid, accountSignatureKey);
-    const accountEnc = encodeSignedDeviceIdentity(account, false);
-    const reply = {
-        tag: 'iq',
-        attrs: {
-            to: 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
-    };
-};
-export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
-    account = { ...account };
-    // set to null if we are not to include the signature key
-    // or if we are including the signature key but it is empty
-    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
-        account.accountSignatureKey = null;
-    }
-    return proto.ADVSignedDeviceIdentity.encode(account).finish();
-};
-//# sourceMappingURL=validate-connection.js.map
-//source baileys github.com/Badzz88/baileys