@merajah/baileys 1.0.9 → 4.2.1

package/lib/Utils/signal.js

@@ -1,153 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids = exports.parseAndInjectE2ESessions = exports.xmppPreKey = exports.xmppSignedPreKey = exports.generateOrGetPreKeys = exports.getPreKeys = exports.createSignalIdentity = void 0;
-const Defaults_1 = require("../Defaults");
-const WABinary_1 = require("../WABinary");
-const crypto_1 = require("./crypto");
-const lodash_1 = require("lodash")
-const generics_1 = require("./generics");
-const createSignalIdentity = (wid, accountSignatureKey) => {
-    return {
-        identifier: { name: wid, deviceId: 0 },
-        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
-    };
-};
-exports.createSignalIdentity = createSignalIdentity;
-const getPreKeys = async ({ get }, min, limit) => {
-    const idList = [];
-    for (let id = min; id < limit; id++) {
-        idList.push(id.toString());
-    }
-    return get('pre-key', idList);
-};
-exports.getPreKeys = getPreKeys;
-const generateOrGetPreKeys = (creds, range) => {
-    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
-    const remaining = range - avaliable;
-    const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
-    const newPreKeys = {};
-    if (remaining > 0) {
-        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = crypto_1.Curve.generateKeyPair();
-        }
-    }
-    return {
-        newPreKeys,
-        lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
-    };
-};
-exports.generateOrGetPreKeys = generateOrGetPreKeys;
-const xmppSignedPreKey = (key) => ({
-    tag: 'skey',
-    attrs: {},
-    content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
-        { tag: 'value', attrs: {}, content: key.keyPair.public },
-        { tag: 'signature', attrs: {}, content: key.signature }
-    ]
-});
-exports.xmppSignedPreKey = xmppSignedPreKey;
-const xmppPreKey = (pair, id) => ({
-    tag: 'key',
-    attrs: {},
-    content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
-        { tag: 'value', attrs: {}, content: pair.public }
-    ]
-});
-exports.xmppPreKey = xmppPreKey;
-const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => (key ? ({
-        keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
-        publicKey: crypto_1.generateSignalPubKey(WABinary_1.getBinaryNodeChildBuffer(key, 'value')),
-        signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
-    }) : undefined)
-    const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
-    for (const node of nodes) {
-        WABinary_1.assertNodeErrorFree(node)
-    }
-    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
-    // So Promise.all doesn't really help here,
-    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
-    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
-    // It's rare case when you need to E2E sessions for so many users, but it's possible
-    const chunkSize = 100
-    const chunks = lodash_1.chunk(nodes, chunkSize)
-    for (const nodesChunk of chunks) {
-        await Promise.all(nodesChunk.map(async (node) => {
-            const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
-            const key = WABinary_1.getBinaryNodeChild(node, 'key')
-            const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
-            const jid = node.attrs.jid
-            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
-            await repository.injectE2ESession({
-                jid,
-                session: {
-                    registrationId: registrationId,
-                    identityKey: crypto_1.generateSignalPubKey(identity),
-                    signedPreKey: extractKey(signedKey),
-                    preKey: extractKey(key)
-                }
-            })
-        }))
-    }
-}
-exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
-const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
-    const extracted = []
-    for (const userResult of result) {
-        const { devices, id } = userResult
-        const { user } = WABinary_1.jidDecode(id)
-        const deviceList = devices?.deviceList
-        if (Array.isArray(deviceList)) {
-            for (const { id: device, keyIndex } of deviceList) {
-                if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
-                    (myUser !== user || myDevice !== device) && // either different user or if me user, not this device
-                    (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-                ) {
-                    extracted.push({ user, device })
-                }
-            }
-        }
-    }
-    return extracted
-}
-exports.extractDeviceJids = extractDeviceJids;
-/**
- * get the next N keys for upload or processing
- * @param count number of pre-keys to get or generate
- */
-const getNextPreKeys = async ({ creds, keys }, count) => {
-    const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.generateOrGetPreKeys)(creds, count);
-    const update = {
-        nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
-        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
-    };
-    await keys.set({ 'pre-key': newPreKeys });
-    const preKeys = await (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
-    return { update, preKeys };
-};
-exports.getNextPreKeys = getNextPreKeys;
-const getNextPreKeysNode = async (state, count) => {
-    const { creds } = state;
-    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
-    const node = {
-        tag: 'iq',
-        attrs: {
-            xmlns: 'encrypt',
-            type: 'set',
-            to: WABinary_1.S_WHATSAPP_NET,
-        },
-        content: [
-            { tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
-            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
-            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
-        ]
-    };
-    return { update, node };
-};
-exports.getNextPreKeysNode = getNextPreKeysNode;

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

@@ -1,13 +0,0 @@
-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

@@ -1,119 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,231 +0,0 @@
-"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

@@ -1,30 +0,0 @@
-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
-    }
-}