@vanzxy/baileys 2.0.0

package/lib/Utils/signal.d.ts

@@ -0,0 +1,82 @@
+export function createSignalIdentity(wid: any, accountSignatureKey: any): {
+    identifier: {
+        name: any;
+        deviceId: number;
+    };
+    identifierKey: any;
+};
+export function getPreKeys({ get }: {
+    get: any;
+}, min: any, limit: any): Promise<any>;
+export function generateOrGetPreKeys(creds: any, range: any): {
+    newPreKeys: {};
+    lastPreKeyId: number;
+    preKeysRange: any[];
+};
+export function xmppSignedPreKey(key: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function xmppPreKey(pair: any, id: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function extractE2ESessionFromRetryReceipt(receipt: any): {
+    registrationId: number | undefined;
+    identityKey: any;
+    signedPreKey: {
+        keyId: number | undefined;
+        publicKey: any;
+        signature: any;
+    };
+    preKey: {
+        keyId: number | undefined;
+        publicKey: any;
+    } | undefined;
+} | null;
+export function parseAndInjectE2ESessions(node: any, repository: any): Promise<void>;
+export function extractDeviceJids(result: any, myJid: any, myLid: any, excludeZeroDevices: any): {
+    user: any;
+    device: any;
+    domainType: any;
+    server: any;
+}[];
+export function getNextPreKeys({ creds, keys }: {
+    creds: any;
+    keys: any;
+}, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    preKeys: any;
+}>;
+export function getNextPreKeysNode(state: any, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    node: {
+        tag: string;
+        attrs: {
+            xmlns: string;
+            type: string;
+            to: string;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: any;
+        }[];
+    };
+}>;

package/lib/Utils/signal.js

@@ -0,0 +1,201 @@
+import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js';
+import { Curve, generateSignalPubKey } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
+function chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}
+export const createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: generateSignalPubKey(accountSignatureKey)
+    };
+};
+export const getPreKeys = async ({ get }, min, limit) => {
+    const idList = [];
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString());
+    }
+    return get('pre-key', idList);
+};
+export 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] = Curve.generateKeyPair();
+        }
+    }
+    return {
+        newPreKeys,
+        lastPreKeyId,
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+    };
+};
+export const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature }
+    ]
+});
+export const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public }
+    ]
+});
+const isValidUInt = (n) => typeof n === 'number' && Number.isInteger(n);
+export const extractE2ESessionFromRetryReceipt = (receipt) => {
+    const keysNode = getBinaryNodeChild(receipt, 'keys');
+    if (!keysNode)
+        return null;
+    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type');
+    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0])
+        return null;
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
+    const skey = getBinaryNodeChild(keysNode, 'skey');
+    if (!identity || identity.length !== 32 || !skey)
+        return null;
+    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4);
+    if (!isValidUInt(registrationId))
+        return null;
+    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value');
+    const signedSig = getBinaryNodeChildBuffer(skey, 'signature');
+    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3);
+    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
+        return null;
+    }
+    const preKeyNode = getBinaryNodeChild(keysNode, 'key');
+    let preKey;
+    if (preKeyNode) {
+        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value');
+        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3);
+        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
+            return null;
+        }
+        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) };
+    }
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: {
+            keyId: signedKeyId,
+            publicKey: generateSignalPubKey(signedPubKey),
+            signature: signedSig
+        },
+        preKey
+    };
+};
+export const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => key
+        ? {
+            keyId: getBinaryNodeChildUInt(key, 'id', 3),
+            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+            signature: getBinaryNodeChildBuffer(key, 'signature')
+        }
+        : undefined;
+    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user');
+    for (const node of nodes) {
+        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 = chunk(nodes, chunkSize);
+    for (const nodesChunk of chunks) {
+        for (const node of nodesChunk) {
+            const signedKey = getBinaryNodeChild(node, 'skey');
+            const key = getBinaryNodeChild(node, 'key');
+            const identity = getBinaryNodeChildBuffer(node, 'identity');
+            const jid = node.attrs.jid;
+            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4);
+            await repository.injectE2ESession({
+                jid,
+                session: {
+                    registrationId: registrationId,
+                    identityKey: generateSignalPubKey(identity),
+                    signedPreKey: extractKey(signedKey),
+                    preKey: extractKey(key)
+                }
+            });
+        }
+    }
+};
+export const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = jidDecode(myJid);
+    const extracted = [];
+    for (const userResult of result) {
+        const { devices, id } = userResult;
+        const decoded = 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) && // if zero devices are not-excluded, or device is non zero
+                ((myUser !== user && myLid !== 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
+            ) {
+                if (isHosted) {
+                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+                }
+                extracted.push({
+                    user,
+                    device,
+                    domainType,
+                    server: getServerFromDomainType(server, domainType)
+                });
+            }
+        }
+    }
+    return extracted;
+};
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = 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 getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    return { update, preKeys };
+};
+export const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state;
+    const { update, preKeys } = await getNextPreKeys(state, count);
+    const node = {
+        tag: 'iq',
+        attrs: {
+            xmlns: 'encrypt',
+            type: 'set',
+            to: S_WHATSAPP_NET
+        },
+        content: [
+            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
+            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
+            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
+            xmppSignedPreKey(creds.signedPreKey)
+        ]
+    };
+    return { update, node };
+};
+//# sourceMappingURL=signal.js.map

package/lib/Utils/stanza-ack.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node: any, errorCode: any, meId: any): {
+    tag: string;
+    attrs: {
+        id: any;
+        to: any;
+        class: any;
+    };
+};

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,38 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+    // WA Web always includes type when present: `n.type || DROP_ATTR`
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+}
+//# sourceMappingURL=stanza-ack.js.map

package/lib/Utils/status.d.ts

@@ -0,0 +1,50 @@
+import type { AnyMessageContent } from '../Types/index.js';
+import type makeWASocket from '../Socket/index.js';
+type WASocket = ReturnType<typeof makeWASocket>;
+export declare const STATUS_BROADCAST_JID = "status@broadcast";
+export declare const STATUS_BACKGROUNDS: {
+    solid: Record<string, string>;
+    gradient: Record<string, string[]>;
+};
+export declare const STATUS_FONTS: {
+    readonly SANS_SERIF: 0;
+    readonly SERIF: 1;
+    readonly NORICAN: 2;
+    readonly BRYNDAN: 3;
+    readonly BEBASNEUE: 4;
+    readonly OSWALD: 5;
+    readonly DAMION: 6;
+    readonly DANCING: 7;
+    readonly COMFORTAA: 8;
+    readonly EXOTWO: 9;
+};
+export type StatusFont = (typeof STATUS_FONTS)[keyof typeof STATUS_FONTS];
+export declare const generateStatusMessageId: () => string;
+export type TextStatusOptions = {
+    text: string;
+    backgroundColor?: string;
+    font?: StatusFont;
+    textColor?: string;
+    mentions?: string[];
+};
+export type MediaStatusOptions = {
+    caption?: string;
+    gifPlayback?: boolean;
+    waveform?: Uint8Array;
+};
+export declare const createTextStatus: (options: TextStatusOptions) => AnyMessageContent;
+export declare const createImageStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const createVideoStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const createAudioStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const getStatusJid: () => string;
+export declare const StatusHelper: {
+    text: (text: string, backgroundColor?: string, font?: StatusFont) => AnyMessageContent;
+    image: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    imageUrl: (url: string, caption?: string) => AnyMessageContent;
+    video: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    videoUrl: (url: string, caption?: string) => AnyMessageContent;
+    gif: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    voiceNote: (buffer: Buffer) => AnyMessageContent;
+    send: (sock: WASocket, content: AnyMessageContent, jidList?: string[]) => Promise<any>;
+};
+export {};

package/lib/Utils/status.js

@@ -0,0 +1,108 @@
+// Vanz@Add --- ported from Bail-master addons/status-helpers.ts (type-only
+// annotations dropped; behavior unchanged). status-posting.ts (the other
+// addon shipping identical STATUS_BACKGROUNDS/STATUS_FONTS/createXStatus/
+// StatusHelper) additionally exposed `makeStatusMentionsAddon`, a
+// socket-factory-style addon requiring deep internal wiring (authState,
+// waUploadToServer, groupMetadata, generateWAMessageContent) matching
+// Baileys' own makeXSocket pattern — left out of this port as too tightly
+// coupled to socket internals to safely merge without live testing.
+// Basic status mentions are still supported via createTextStatus's own
+// `mentions` option (contextInfo.mentionedJid).
+import { randomBytes } from 'crypto';
+export const STATUS_BROADCAST_JID = 'status@broadcast';
+export const STATUS_BACKGROUNDS = {
+    solid: {
+        green: '#25D366',
+        blue: '#34B7F1',
+        purple: '#8B5CF6',
+        red: '#EF4444',
+        orange: '#F97316',
+        yellow: '#EAB308',
+        pink: '#EC4899',
+        teal: '#14B8A6',
+        gray: '#6B7280',
+        black: '#000000',
+        white: '#FFFFFF'
+    },
+    gradient: {
+        sunset: ['#F97316', '#EF4444'],
+        ocean: ['#3B82F6', '#06B6D4'],
+        forest: ['#22C55E', '#10B981'],
+        purple: ['#8B5CF6', '#EC4899'],
+        midnight: ['#1E3A8A', '#4C1D95'],
+        aurora: ['#06B6D4', '#8B5CF6', '#EC4899']
+    }
+};
+export const STATUS_FONTS = {
+    SANS_SERIF: 0,
+    SERIF: 1,
+    NORICAN: 2,
+    BRYNDAN: 3,
+    BEBASNEUE: 4,
+    OSWALD: 5,
+    DAMION: 6,
+    DANCING: 7,
+    COMFORTAA: 8,
+    EXOTWO: 9
+};
+/** Generate a status message ID with a 4NY4W3B prefix. */
+export const generateStatusMessageId = () => `4NY4W3B${randomBytes(16).toString('hex').toUpperCase()}`;
+export const createTextStatus = (options) => ({
+    text: options.text,
+    backgroundColor: options.backgroundColor || STATUS_BACKGROUNDS.solid.green,
+    font: options.font ?? STATUS_FONTS.SANS_SERIF,
+    textColor: options.textColor || '#FFFFFF',
+    contextInfo: { mentionedJid: options.mentions || [], isForwarded: false }
+});
+export const createImageStatus = (media, options) => ({
+    image: typeof media === 'string' ? { url: media } : media,
+    caption: options?.caption || ''
+});
+export const createVideoStatus = (media, options) => ({
+    video: typeof media === 'string' ? { url: media } : media,
+    caption: options?.caption || '',
+    gifPlayback: options?.gifPlayback || false
+});
+export const createAudioStatus = (media, options) => ({
+    audio: typeof media === 'string' ? { url: media } : media,
+    ptt: true,
+    mimetype: 'audio/ogg; codecs=opus',
+    waveform: options?.waveform
+});
+export const getStatusJid = () => STATUS_BROADCAST_JID;
+/** Convenience wrappers + a `send()` that routes group vs. individual/broadcast status delivery. */
+export const StatusHelper = {
+    text: (text, backgroundColor, font) => createTextStatus({ text, backgroundColor, font }),
+    image: (buffer, caption) => createImageStatus(buffer, { caption }),
+    imageUrl: (url, caption) => createImageStatus(url, { caption }),
+    video: (buffer, caption) => createVideoStatus(buffer, { caption }),
+    videoUrl: (url, caption) => createVideoStatus(url, { caption }),
+    gif: (buffer, caption) => createVideoStatus(buffer, { caption, gifPlayback: true }),
+    voiceNote: (buffer) => createAudioStatus(buffer),
+    /**
+     * Send a status to specific JIDs (groups and/or individuals).
+     * Handles group status (groupStatus:true) and broadcast (status@broadcast) separately.
+     * Pass an empty jidList (or omit it) to broadcast to everyone.
+     */
+    send: async (sock, content, jidList = []) => {
+        const groups = jidList.filter((j) => j?.endsWith('@g.us'));
+        const individuals = jidList.filter((j) => j?.endsWith('@s.whatsapp.net') || j?.endsWith('@lid'));
+        let lastResult;
+        if (groups.length > 0) {
+            const groupContent = { ...content, groupStatus: true };
+            for (const groupJid of groups) {
+                lastResult = await sock.sendMessage(groupJid, groupContent, { messageId: generateStatusMessageId() });
+            }
+        }
+        if (individuals.length > 0 || jidList.length === 0) {
+            const result = await sock.sendMessage(STATUS_BROADCAST_JID, content, {
+                statusJidList: individuals.length > 0 ? individuals : undefined,
+                messageId: generateStatusMessageId()
+            });
+            if (!lastResult)
+                lastResult = result;
+        }
+        return lastResult;
+    }
+};
+//# sourceMappingURL=status.js.map

package/lib/Utils/stickerpack.d.ts

@@ -0,0 +1,51 @@
+import type { ILogger } from './logger.js';
+import type { WAMediaUpload } from '../Types/index.js';
+import { proto } from '../../WAProto/index.js';
+export declare const isWebPBuffer: (buffer: Buffer) => boolean;
+export declare const isAnimatedWebP: (buffer: Buffer) => boolean;
+export declare const convertToWebP: (input: WAMediaUpload) => Promise<{
+    buffer: Buffer;
+    isAnimated: boolean;
+}>;
+export declare const generateStickerPackId: () => string;
+export declare const buildStickerPackProto: (pack: {
+    name: string;
+    publisher: string;
+    packId?: string;
+    description?: string;
+}) => {
+    name: string;
+    publisher: string;
+    packId: string;
+    description: string;
+};
+export declare const STICKER_PACK_MESSAGE_TYPE: 'sticker_pack';
+export type ItsliaaaStickerInput = {
+    data: WAMediaUpload;
+    emojis?: string[];
+    accessibilityLabel?: string;
+};
+export type ItsliaaaStickerPackInput = {
+    cover: WAMediaUpload;
+    stickers: ItsliaaaStickerInput[];
+    name?: string;
+    publisher?: string;
+    description?: string;
+};
+export type ItsliaaaStickerPackOptions = {
+    logger?: ILogger;
+    upload: (filePath: string, opts: {
+        fileEncSha256B64: string;
+        mediaType: string;
+        timeoutMs?: number;
+    }) => Promise<{
+        directPath: string;
+    }>;
+    options?: RequestInit;
+    mediaUploadTimeoutMs?: number;
+    mediaCache?: {
+        get: (key: string) => Promise<Buffer | undefined>;
+        set: (key: string, value: Buffer) => void;
+    };
+};
+export declare const prepareStickerPackMessageItsliaaa: (message: ItsliaaaStickerPackInput, options: ItsliaaaStickerPackOptions) => Promise<proto.Message.IStickerPackMessage>;