@badzz88/baileys 8.5.6 → 8.5.8

package/src/Utils/session-pool.d.ts

@@ -1,14 +0,0 @@
-export interface SessionPoolOptions {
-    makeSocket: (sessionId: string) => Promise<any> | any;
-    logger?: any;
-    maxBackoffMs?: number;
-    onSessionUpdate?: (sessionId: string, sock: any) => void;
-    onLoggedOut?: (sessionId: string) => void;
-}
-export interface SessionPool {
-    add: (sessionId: string) => Promise<void>;
-    remove: (sessionId: string) => void;
-    get: (sessionId: string) => any;
-    list: () => string[];
-}
-export function createSessionPool(options: SessionPoolOptions): SessionPool;

package/src/Utils/session-pool.js

@@ -1,70 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.createSessionPool = void 0;
-const DISCONNECT_REASON_LOGGED_OUT = 401;
-const createSessionPool = options => {
-    const logger = options.logger;
-    const maxBackoffMs = options.maxBackoffMs ?? 60000;
-    const sessions = new Map();
-    const computeBackoffMs = attempts => {
-        const base = Math.min(1000 * 2 ** attempts, maxBackoffMs);
-        return base + Math.floor(Math.random() * (base * 0.2));
-    };
-    const start = async (sessionId) => {
-        const entry = sessions.get(sessionId) || { attempts: 0, stopped: false };
-        sessions.set(sessionId, entry);
-        if (entry.stopped)
-            return;
-        try {
-            const sock = await options.makeSocket(sessionId);
-            entry.sock = sock;
-            options.onSessionUpdate?.(sessionId, sock);
-            sock.ev.on('connection.update', update => {
-                if (update.connection === 'open') {
-                    entry.attempts = 0;
-                }
-                if (update.connection === 'close') {
-                    const statusCode = update.lastDisconnect?.error?.output?.statusCode;
-                    if (statusCode === DISCONNECT_REASON_LOGGED_OUT) {
-                        logger?.info?.({ sessionId }, 'session logged out, removing from pool');
-                        sessions.delete(sessionId);
-                        options.onLoggedOut?.(sessionId);
-                        return;
-                    }
-                    if (entry.stopped)
-                        return;
-                    entry.attempts += 1;
-                    const backoffMs = computeBackoffMs(entry.attempts);
-                    logger?.warn?.({ sessionId, attempt: entry.attempts, backoffMs }, 'session disconnected, reconnecting with backoff');
-                    setTimeout(() => start(sessionId), backoffMs);
-                }
-            });
-        }
-        catch (error) {
-            entry.attempts += 1;
-            const backoffMs = computeBackoffMs(entry.attempts);
-            logger?.error?.({ error, sessionId, backoffMs }, 'failed to start session, retrying with backoff');
-            if (!entry.stopped) {
-                setTimeout(() => start(sessionId), backoffMs);
-            }
-        }
-    };
-    const add = sessionId => start(sessionId);
-    const remove = sessionId => {
-        const entry = sessions.get(sessionId);
-        if (!entry)
-            return;
-        entry.stopped = true;
-        if (entry.sock?.end) {
-            try {
-                entry.sock.end(undefined);
-            }
-            catch { }
-        }
-        sessions.delete(sessionId);
-    };
-    const get = sessionId => sessions.get(sessionId)?.sock;
-    const list = () => [...sessions.keys()];
-    return { add, remove, get, list };
-};
-exports.createSessionPool = createSessionPool;

package/src/Utils/signal.js

@@ -1,217 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getNextPreKeysNode =
-    exports.getNextPreKeys =
-        exports.extractDeviceJids =
-            exports.parseAndInjectE2ESessions =
-                exports.extractE2ESessionFromRetryReceipt =
-                    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 generics_1 = require('./generics');
-function chunk(array, size) {
-    const chunks = [];
-    for (let i = 0; i < array.length; i += size) {
-        chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-}
-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 isValidUInt = n => typeof n === 'number' && Number.isInteger(n);
-const extractE2ESessionFromRetryReceipt = receipt => {
-    const keysNode = (0, WABinary_1.getBinaryNodeChild)(receipt, 'keys');
-    if (!keysNode)
-        return null;
-    const typeBuf = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'type');
-    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== Defaults_1.KEY_BUNDLE_TYPE[0])
-        return null;
-    const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'identity');
-    const skey = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'skey');
-    if (!identity || identity.length !== 32 || !skey)
-        return null;
-    const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(receipt, 'registration', 4);
-    if (!isValidUInt(registrationId))
-        return null;
-    const signedPubKey = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'value');
-    const signedSig = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'signature');
-    const signedKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(skey, 'id', 3);
-    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
-        return null;
-    }
-    const preKeyNode = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'key');
-    let preKey;
-    if (preKeyNode) {
-        const preKeyPub = (0, WABinary_1.getBinaryNodeChildBuffer)(preKeyNode, 'value');
-        const preKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(preKeyNode, 'id', 3);
-        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
-            return null;
-        }
-        preKey = { keyId: preKeyId, publicKey: (0, crypto_1.generateSignalPubKey)(preKeyPub) };
-    }
-    return {
-        registrationId,
-        identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-        signedPreKey: {
-            keyId: signedKeyId,
-            publicKey: (0, crypto_1.generateSignalPubKey)(signedPubKey),
-            signature: signedSig
-        },
-        preKey
-    };
-};
-exports.extractE2ESessionFromRetryReceipt = extractE2ESessionFromRetryReceipt;
-const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = key => key
-        ? {
-            keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
-            publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
-            signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature')
-        }
-        : undefined;
-    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
-    for (const node of nodes) {
-        ;
-        (0, WABinary_1.assertNodeErrorFree)(node);
-    }
-    const chunkSize = 100;
-    const chunks = chunk(nodes, chunkSize);
-    for (const nodesChunk of chunks) {
-        for (const node of nodesChunk) {
-            const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
-            const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
-            const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
-            const jid = node.attrs.jid;
-            const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
-            await repository.injectE2ESession({
-                jid,
-                session: {
-                    registrationId: registrationId,
-                    identityKey: (0, crypto_1.generateSignalPubKey)(identity),
-                    signedPreKey: extractKey(signedKey),
-                    preKey: extractKey(key)
-                }
-            });
-        }
-    }
-};
-exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
-const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
-    const extracted = [];
-    for (const userResult of result) {
-        const { devices, id } = userResult;
-        const decoded = (0, WABinary_1.jidDecode)(id), { user, server } = decoded;
-        let { domainType } = decoded;
-        const deviceList = devices?.deviceList;
-        if (!Array.isArray(deviceList))
-            continue;
-        for (const { id: device, keyIndex, isHosted } of deviceList) {
-            if ((!excludeZeroDevices || device !== 0) &&
-                ((myUser !== user && myLid !== user) || myDevice !== device) &&
-                (device === 0 || !!keyIndex)) {
-                if (isHosted) {
-                    domainType =
-                        domainType === WABinary_1.WAJIDDomains.LID
-                            ? WABinary_1.WAJIDDomains.HOSTED_LID
-                            : WABinary_1.WAJIDDomains.HOSTED;
-                }
-                extracted.push({
-                    user,
-                    device,
-                    domainType,
-                    server: (0, WABinary_1.getServerFromDomainType)(server, domainType)
-                });
-            }
-        }
-    }
-    return extracted;
-};
-exports.extractDeviceJids = extractDeviceJids;
-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/src/Utils/sticker.d.ts

@@ -1,13 +0,0 @@
-export interface StickerMetaOptions {
-    packName?: string;
-    packPublisher?: string;
-    categories?: string[];
-}
-export function addExifToWebp(webpBuffer: Buffer, options?: StickerMetaOptions): Promise<Buffer>;
-export function imageToWebpSticker(imageBuffer: Buffer, options?: StickerMetaOptions & {
-    quality?: number;
-}): Promise<Buffer>;
-export function videoToWebpSticker(videoBuffer: Buffer, options?: StickerMetaOptions & {
-    fps?: number;
-    seconds?: number;
-}): Promise<Buffer>;

package/src/Utils/sticker.js

@@ -1,123 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.imageToWebpSticker = exports.videoToWebpSticker = exports.addExifToWebp = void 0;
-const os = require('os');
-const path = require('path');
-const fs = require('fs');
-const crypto = require('crypto');
-const { exec } = require('child_process');
-const addExifToWebp = async (webpBuffer, { packName = '', packPublisher = '', categories = [] } = {}) => {
-    const json = {
-        'sticker-pack-id': crypto.randomBytes(16).toString('hex'),
-        'sticker-pack-name': packName,
-        'sticker-pack-publisher': packPublisher,
-        emojis: categories.length ? categories : ['😀']
-    };
-    const jsonBuffer = Buffer.from(JSON.stringify(json), 'utf-8');
-    const exifAttr = Buffer.from([
-        0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
-        0x00, 0x00, 0x00
-    ]);
-    exifAttr.writeUIntLE(jsonBuffer.length, 14, 4);
-    const exifPayload = Buffer.concat([exifAttr, jsonBuffer]);
-    const pad = buf => (buf.length % 2 === 1 ? Buffer.concat([buf, Buffer.from([0x00])]) : buf);
-    const makeChunk = (tag, data) => {
-        const sizeField = Buffer.alloc(4);
-        sizeField.writeUInt32LE(data.length, 0);
-        return Buffer.concat([Buffer.from(tag, 'ascii'), sizeField, pad(data)]);
-    };
-    const exifChunk = makeChunk('EXIF', exifPayload);
-    if (webpBuffer.slice(0, 4).toString('ascii') !== 'RIFF' || webpBuffer.slice(8, 12).toString('ascii') !== 'WEBP') {
-        throw new Error('addExifToWebp expects a valid WebP buffer');
-    }
-    let offset = 12;
-    let vp8xChunk = null;
-    let vp8xOffset = -1;
-    const otherChunks = [];
-    while (offset < webpBuffer.length) {
-        const tag = webpBuffer.slice(offset, offset + 4).toString('ascii');
-        const size = webpBuffer.readUInt32LE(offset + 4);
-        const dataStart = offset + 8;
-        const dataEnd = dataStart + size;
-        const chunkTotal = 8 + size + (size % 2);
-        if (tag === 'VP8X') {
-            vp8xChunk = webpBuffer.slice(offset, offset + chunkTotal);
-            vp8xOffset = offset;
-        }
-        else if (tag !== 'EXIF') {
-            otherChunks.push(webpBuffer.slice(offset, offset + chunkTotal));
-        }
-        offset += chunkTotal;
-    }
-    let flags;
-    let canvasWidth;
-    let canvasHeight;
-    if (vp8xChunk) {
-        flags = vp8xChunk.readUInt8(8);
-        canvasWidth = vp8xChunk.readUIntLE(12, 3) + 1;
-        canvasHeight = vp8xChunk.readUIntLE(15, 3) + 1;
-    }
-    else {
-        flags = 0;
-        let sharp;
-        try {
-            sharp = require('sharp');
-        }
-        catch (error) {
-            throw new Error('addExifToWebp needs the optional "sharp" dependency to read image dimensions');
-        }
-        const meta = await sharp(webpBuffer).metadata();
-        canvasWidth = meta.width;
-        canvasHeight = meta.height;
-    }
-    flags |= 0x08;
-    const vp8xData = Buffer.alloc(10);
-    vp8xData.writeUInt8(flags, 0);
-    vp8xData.writeUIntLE(canvasWidth - 1, 4, 3);
-    vp8xData.writeUIntLE(canvasHeight - 1, 7, 3);
-    const newVp8xChunk = makeChunk('VP8X', vp8xData);
-    const body = Buffer.concat([newVp8xChunk, ...otherChunks, exifChunk]);
-    const fileSize = Buffer.alloc(4);
-    fileSize.writeUInt32LE(4 + body.length, 0);
-    return Buffer.concat([Buffer.from('RIFF', 'ascii'), fileSize, Buffer.from('WEBP', 'ascii'), body]);
-};
-exports.addExifToWebp = addExifToWebp;
-const imageToWebpSticker = async (imageBuffer, options = {}) => {
-    let sharp;
-    try {
-        sharp = require('sharp');
-    }
-    catch (error) {
-        throw new Error('imageToWebpSticker requires the optional "sharp" dependency to be installed');
-    }
-    const webp = await sharp(imageBuffer)
-        .resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-        .webp({ quality: options.quality ?? 80 })
-        .toBuffer();
-    return addExifToWebp(webp, options);
-};
-exports.imageToWebpSticker = imageToWebpSticker;
-const videoToWebpSticker = async (videoBuffer, options = {}) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'xazbails-sticker-'));
-    const inputPath = path.join(tmpDir, 'input.mp4');
-    const outputPath = path.join(tmpDir, 'output.webp');
-    fs.writeFileSync(inputPath, videoBuffer);
-    const fps = options.fps ?? 10;
-    const seconds = options.seconds ?? 5;
-    const cmd = `ffmpeg -y -i ${inputPath} -t ${seconds} -vf ` +
-        `"fps=${fps},scale=512:512:force_original_aspect_ratio=decrease,` +
-        `pad=512:512:(ow-iw)/2:(oh-ih)/2:color=0x00000000,split[a][b];` +
-        `[a]palettegen=reserve_transparent=1[p];[b][p]paletteuse" ` +
-        `-loop 0 -preset default -an -vsync 0 ${outputPath}`;
-    try {
-        await new Promise((resolve, reject) => {
-            exec(cmd, err => (err ? reject(err) : resolve()));
-        });
-        const webp = fs.readFileSync(outputPath);
-        return await addExifToWebp(webp, options);
-    }
-    finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-};
-exports.videoToWebpSticker = videoToWebpSticker;

package/src/Utils/validate-connection.js

@@ -1,209 +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 Crypto_1 = require('./crypto');
-const index_js_1 = require('../../WAProto/index.js');
-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: index_js_1.proto.ClientPayload.UserAgent.Platform.WEB,
-        releaseChannel: index_js_1.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': index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
-};
-const getWebInfo = config => {
-    let webSubPlatform = index_js_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: index_js_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: index_js_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: getUserAgent(config)
-    };
-    payload.webInfo = getWebInfo(config);
-    return payload;
-};
-const generateLoginNode = (userJid, config, creds) => {
-    const { user, device } = (0, WABinary_1.jidDecode)(userJid);
-    const effectiveDevice = config.masqueradeAsPrimary ? 0 : device;
-    const payload = {
-        ...getClientPayload(config),
-        passive: !config.masqueradeAsPrimary,
-        pull: !config.masqueradeAsPrimary,
-        username: +user,
-        device: effectiveDevice,
-        lidDbMigrated: false
-    };
-    if (creds?.interopData?.accountId) {
-        payload.interopData = {
-            accountId: creds.interopData.accountId,
-            token: creds.interopData.token,
-            enableReadReceipts: creds.interopData.enableReadReceipts ?? true
-        };
-    }
-    return index_js_1.proto.ClientPayload.fromObject(payload);
-};
-exports.generateLoginNode = generateLoginNode;
-const getPlatformType = platform => {
-    const platformType = platform.toUpperCase();
-    return index_js_1.proto.DeviceProps.PlatformType[platformType] || index_js_1.proto.DeviceProps.PlatformType.CHROME;
-};
-const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
-    const appVersionBuf = Buffer.from(Crypto_1.md5(Buffer.from(config.version.join('.'))));
-    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 = index_js_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 index_js_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 } = index_js_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-    let hmacPrefix = Buffer.from([]);
-    if (accountType !== undefined && accountType === index_js_1.proto.ADVEncryptionType.HOSTED) {
-        hmacPrefix = Defaults_1.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
-    }
-    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 = index_js_1.proto.ADVSignedDeviceIdentity.decode(details);
-    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
-    const deviceIdentity = index_js_1.proto.ADVDeviceIdentity.decode(deviceDetails);
-    const accountSignaturePrefix = deviceIdentity.deviceType === index_js_1.proto.ADVEncryptionType.HOSTED
-        ? Defaults_1.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
-        : Defaults_1.WA_ADV_ACCOUNT_SIG_PREFIX;
-    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([
-        Defaults_1.WA_ADV_DEVICE_SIG_PREFIX,
-        deviceDetails,
-        signedIdentityKey.public,
-        accountSignatureKey
-    ]);
-    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg);
-    const identity = (0, signal_1.createSignalIdentity)(lid, 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 index_js_1.proto.ADVSignedDeviceIdentity.encode(account).finish();
-};
-exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;

package/src/Utils/view-once-cache.d.ts

@@ -1,12 +0,0 @@
-export interface AutoCacheViewOnceOptions {
-    cacheDir?: string;
-    logger?: any;
-    onCached?: (info: {
-        id: string;
-        jid: string;
-        filePath: string;
-        type: string;
-    }) => void;
-}
-export function getViewOnceContent(message: any): Record<string, any> | null;
-export function autoCacheViewOnceMedia(sock: any, options?: AutoCacheViewOnceOptions): () => void;