@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/Utils/scheduled-message.d.ts

@@ -0,0 +1,81 @@
+export const SCHEDULED_MSG_META_TYPE: "scheduled_message";
+export const SCHEDULED_MSG_MAX_PER_CHAT: 30;
+export const SCHEDULED_MSG_MAX_MEDIA: 1;
+export const SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE: 419;
+export const SCHEDULED_MSG_REVEAL_KEY_BYTES: 32;
+export const SCHEDULED_MSG_REVEAL_KEY_IV_BYTES: 12;
+export const SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS: 30;
+export const SCHEDULED_MSG_TAG_BYTES: 16;
+export const SCHEDULED_MSG_WINDOW: Readonly<{
+    chat: {
+        minSeconds: number;
+        maxSeconds: number;
+    };
+    newsletter: {
+        minSeconds: number;
+        maxSeconds: number;
+    };
+}>;
+export function generateRevealKey(): any;
+export function generateRevealKeyId(): any;
+export function encryptWithRevealKey(plaintext: any, revealKey: any): {
+    encIv: any;
+    encPayload: any;
+};
+export function decryptWithRevealKey(encPayload: any, encIv: any, revealKey: any): any;
+export function buildConditionalRevealMessage(opts1: { [key: string]: any; 
+    encPayload: any;
+    encIv: any;
+    revealKeyId: any;
+}): {
+    conditionalRevealMessage: {
+        conditionalRevealMessageType: proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType;
+        encPayload: any;
+        encIv: any;
+        revealKeyId: any;
+    };
+};
+export function encodeScheduledMessage(message: any, revealKey?: any): {
+    revealKey: any;
+    revealKeyId: any;
+    encIv: any;
+    encPayload: any;
+    message: {
+        conditionalRevealMessage: {
+            conditionalRevealMessageType: proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType;
+            encPayload: any;
+            encIv: any;
+            revealKeyId: any;
+        };
+    };
+};
+export function decodeScheduledMessage(conditionalRevealMessage: any, revealKey: any): proto.Message;
+export function buildScheduledMsgMetaNode(opts2: { [key: string]: any; 
+    kind?: string;
+    scheduledTimestampS: any;
+    revealKeyId: any;
+    revealKey: any;
+}): {
+    tag: string;
+    attrs: {
+        type: string;
+    };
+    content: {
+        tag: string;
+        attrs: {
+            rkid: any;
+        };
+        content: any;
+    }[];
+};
+export function buildUnscheduleProtocolMessage(key: any): {
+    protocolMessage: {
+        key: any;
+        type: proto.Message.ProtocolMessage.Type;
+    };
+};
+export function isScheduledTimeValid(scheduledTimestampS: any, nowSeconds?: number, window?: {
+    minSeconds: number;
+    maxSeconds: number;
+}): boolean;
+import { proto } from '../../WAProto/index.js';

package/lib/Utils/scheduled-message.js

@@ -0,0 +1,101 @@
+// Vanz@Port --- ported from @blurose/baileys 1.1.23 (scheduled-message.js). Creator credits untouched. See NOTICE.md.
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+export const SCHEDULED_MSG_META_TYPE = 'scheduled_message';
+export const SCHEDULED_MSG_MAX_PER_CHAT = 30;
+export const SCHEDULED_MSG_MAX_MEDIA = 1;
+export const SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE = 419;
+export const SCHEDULED_MSG_REVEAL_KEY_BYTES = 32;
+export const SCHEDULED_MSG_REVEAL_KEY_IV_BYTES = 12;
+export const SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS = 30;
+export const SCHEDULED_MSG_TAG_BYTES = 16;
+export const SCHEDULED_MSG_WINDOW = Object.freeze({
+    chat: { minSeconds: 600, maxSeconds: 1209600 },
+    newsletter: { minSeconds: 600, maxSeconds: 2592000 }
+});
+export const generateRevealKey = () => randomBytes(SCHEDULED_MSG_REVEAL_KEY_BYTES);
+export const generateRevealKeyId = () => randomUUID();
+export const encryptWithRevealKey = (plaintext, revealKey) => {
+    const key = Buffer.from(revealKey);
+    if (key.length !== SCHEDULED_MSG_REVEAL_KEY_BYTES) {
+        throw new TypeError(`reveal key must be ${SCHEDULED_MSG_REVEAL_KEY_BYTES} bytes`);
+    }
+    const encIv = randomBytes(SCHEDULED_MSG_REVEAL_KEY_IV_BYTES);
+    const cipher = createCipheriv('aes-256-gcm', key, encIv);
+    const body = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()]);
+    return { encIv, encPayload: Buffer.concat([body, cipher.getAuthTag()]) };
+};
+export const decryptWithRevealKey = (encPayload, encIv, revealKey) => {
+    const key = Buffer.from(revealKey);
+    const payload = Buffer.from(encPayload);
+    if (payload.length < SCHEDULED_MSG_TAG_BYTES) {
+        throw new TypeError('encrypted payload is too short to carry an auth tag');
+    }
+    const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(encIv));
+    decipher.setAuthTag(payload.subarray(payload.length - SCHEDULED_MSG_TAG_BYTES));
+    return Buffer.concat([
+        decipher.update(payload.subarray(0, payload.length - SCHEDULED_MSG_TAG_BYTES)),
+        decipher.final()
+    ]);
+};
+export const buildConditionalRevealMessage = ({ encPayload, encIv, revealKeyId }) => ({
+    conditionalRevealMessage: {
+        conditionalRevealMessageType: proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType.SCHEDULED_MESSAGE,
+        encPayload: Buffer.from(encPayload),
+        encIv: Buffer.from(encIv),
+        revealKeyId
+    }
+});
+export const encodeScheduledMessage = (message, revealKey = generateRevealKey()) => {
+    const plaintext = proto.Message.encode(proto.Message.fromObject(message)).finish();
+    const { encIv, encPayload } = encryptWithRevealKey(plaintext, revealKey);
+    const revealKeyId = generateRevealKeyId();
+    return {
+        revealKey,
+        revealKeyId,
+        encIv,
+        encPayload,
+        message: buildConditionalRevealMessage({ encPayload, encIv, revealKeyId })
+    };
+};
+export const decodeScheduledMessage = (conditionalRevealMessage, revealKey) => {
+    const inner = conditionalRevealMessage?.conditionalRevealMessage ?? conditionalRevealMessage;
+    if (!inner?.encPayload || !inner?.encIv) {
+        throw new TypeError('conditionalRevealMessage is missing encPayload or encIv');
+    }
+    return proto.Message.decode(decryptWithRevealKey(inner.encPayload, inner.encIv, revealKey));
+};
+export const buildScheduledMsgMetaNode = ({ kind = 'schedule', scheduledTimestampS, revealKeyId, revealKey }) => {
+    if (!revealKeyId) {
+        throw new TypeError('revealKeyId is required');
+    }
+    if (kind === 'schedule' && !revealKey) {
+        throw new TypeError('scheduling requires the reveal key');
+    }
+    const attrs = { type: SCHEDULED_MSG_META_TYPE };
+    if (kind === 'schedule') {
+        if (scheduledTimestampS === undefined || !Number.isFinite(Number(scheduledTimestampS))) {
+            throw new TypeError('scheduledTimestampS must be a unix timestamp in seconds');
+        }
+        attrs.st = String(Math.floor(Number(scheduledTimestampS)));
+    }
+    return {
+        tag: 'meta',
+        attrs,
+        content: [{
+                tag: 'key',
+                attrs: { rkid: revealKeyId },
+                content: kind === 'schedule' ? Buffer.from(revealKey) : undefined
+            }]
+    };
+};
+export const buildUnscheduleProtocolMessage = (key) => ({
+    protocolMessage: {
+        key,
+        type: proto.Message.ProtocolMessage.Type.MESSAGE_UNSCHEDULE
+    }
+});
+export const isScheduledTimeValid = (scheduledTimestampS, nowSeconds = Math.floor(Date.now() / 1000), window = SCHEDULED_MSG_WINDOW.chat) => {
+    const rounded = Math.floor(nowSeconds / 60) * 60;
+    return scheduledTimestampS - rounded >= window.minSeconds && scheduledTimestampS - nowSeconds <= window.maxSeconds;
+};

package/lib/Utils/scheduling.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ported from Bail-master addons/scheduling.ts + message-scheduler.ts.
+ * Bail-master shipped these as two separate, overlapping schedulers (one class-based
+ * with polling, one function-based with setTimeout + repeat support). Merged here into
+ * a single class-based scheduler so multiple independent instances can be bound to
+ * different sendMessage functions (e.g. multi-session bots), while keeping the
+ * repeat-interval/maxRepeats feature from the function-based version.
+ */
+export class MessageScheduler {
+    constructor(sendMessage: any, options?: {});
+    queue: Map<any, any>;
+    timer: any;
+    sendMessage: any;
+    options: {
+        maxQueue: any;
+        checkInterval: any;
+        onSent: any;
+        onFailed: any;
+    };
+    generateId(): string;
+    /**
+     * Schedule a message for a specific Date. Pass `repeatIntervalMs` to
+     * re-queue the job that many ms after each send (optionally capped by
+     * `maxRepeats`).
+     */
+    schedule(jid: any, content: any, scheduledTime: any, repeatOptions: any): {
+        id: string;
+        jid: any;
+        content: any;
+        scheduledTime: any;
+        createdAt: Date;
+        status: string;
+        repeatIntervalMs: any;
+        maxRepeats: any;
+        repeatCount: number;
+    };
+    scheduleDelay(jid: any, content: any, delayMs: any, repeatOptions: any): {
+        id: string;
+        jid: any;
+        content: any;
+        scheduledTime: any;
+        createdAt: Date;
+        status: string;
+        repeatIntervalMs: any;
+        maxRepeats: any;
+        repeatCount: number;
+    };
+    cancel(id: any): boolean;
+    cancelForJid(jid: any): number;
+    getPending(): any[];
+    get(id: any): any;
+    clearAll(): number;
+    processQueue(): Promise<void>;
+    ensureTimerRunning(): void;
+    stopTimer(): void;
+    stop(): void;
+    start(): void;
+}
+export function createMessageScheduler(sendMessage: any, options: any): MessageScheduler;

package/lib/Utils/scheduling.js

@@ -0,0 +1,139 @@
+/**
+ * ported from Bail-master addons/scheduling.ts + message-scheduler.ts.
+ * Bail-master shipped these as two separate, overlapping schedulers (one class-based
+ * with polling, one function-based with setTimeout + repeat support). Merged here into
+ * a single class-based scheduler so multiple independent instances can be bound to
+ * different sendMessage functions (e.g. multi-session bots), while keeping the
+ * repeat-interval/maxRepeats feature from the function-based version.
+ */
+export class MessageScheduler {
+    queue = new Map();
+    timer = null;
+    sendMessage;
+    options;
+    constructor(sendMessage, options = {}) {
+        this.sendMessage = sendMessage;
+        this.options = {
+            maxQueue: options.maxQueue ?? 1000,
+            checkInterval: options.checkInterval ?? 1000,
+            onSent: options.onSent ?? (() => { }),
+            onFailed: options.onFailed ?? (() => { })
+        };
+    }
+    generateId() {
+        return `sched_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Schedule a message for a specific Date. Pass `repeatIntervalMs` to
+     * re-queue the job that many ms after each send (optionally capped by
+     * `maxRepeats`).
+     */
+    schedule(jid, content, scheduledTime, repeatOptions) {
+        if (this.queue.size >= this.options.maxQueue)
+            throw new Error(`Maximum queue size (${this.options.maxQueue}) reached`);
+        if (scheduledTime.getTime() <= Date.now())
+            throw new Error('Scheduled time must be in the future');
+        const scheduled = {
+            id: this.generateId(),
+            jid,
+            content,
+            scheduledTime,
+            createdAt: new Date(),
+            status: 'pending',
+            repeatIntervalMs: repeatOptions?.repeatIntervalMs,
+            maxRepeats: repeatOptions?.maxRepeats,
+            repeatCount: 0
+        };
+        this.queue.set(scheduled.id, scheduled);
+        this.ensureTimerRunning();
+        return scheduled;
+    }
+    scheduleDelay(jid, content, delayMs, repeatOptions) {
+        return this.schedule(jid, content, new Date(Date.now() + delayMs), repeatOptions);
+    }
+    cancel(id) {
+        const s = this.queue.get(id);
+        if (s?.status === 'pending') {
+            s.status = 'cancelled';
+            this.queue.delete(id);
+            return true;
+        }
+        return false;
+    }
+    cancelForJid(jid) {
+        let cancelled = 0;
+        for (const [id, s] of this.queue) {
+            if (s.jid === jid && s.status === 'pending') {
+                s.status = 'cancelled';
+                this.queue.delete(id);
+                cancelled++;
+            }
+        }
+        return cancelled;
+    }
+    getPending() {
+        return Array.from(this.queue.values()).filter((s) => s.status === 'pending');
+    }
+    get(id) {
+        return this.queue.get(id);
+    }
+    clearAll() {
+        const count = this.queue.size;
+        this.queue.clear();
+        this.stopTimer();
+        return count;
+    }
+    async processQueue() {
+        const now = Date.now();
+        for (const [id, s] of this.queue) {
+            if (s.status !== 'pending')
+                continue;
+            if (s.scheduledTime.getTime() > now)
+                continue;
+            try {
+                const message = await this.sendMessage(s.jid, s.content);
+                s.messageId = message?.key?.id ?? undefined;
+                this.options.onSent(s, message);
+                // Handle repeating jobs — re-arm instead of removing from the queue.
+                if (s.repeatIntervalMs && s.repeatIntervalMs > 0) {
+                    const nextCount = (s.repeatCount ?? 0) + 1;
+                    if (s.maxRepeats === undefined || nextCount < s.maxRepeats) {
+                        s.repeatCount = nextCount;
+                        s.scheduledTime = new Date(Date.now() + s.repeatIntervalMs);
+                        s.status = 'pending';
+                        continue;
+                    }
+                }
+                s.status = 'sent';
+            }
+            catch (error) {
+                s.status = 'failed';
+                s.error = error?.message || String(error);
+                this.options.onFailed(s, error);
+            }
+            this.queue.delete(id);
+        }
+        if (this.queue.size === 0)
+            this.stopTimer();
+    }
+    ensureTimerRunning() {
+        if (!this.timer) {
+            this.timer = setInterval(() => this.processQueue(), this.options.checkInterval);
+            this.timer?.unref?.();
+        }
+    }
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    stop() {
+        this.stopTimer();
+    }
+    start() {
+        if (this.queue.size > 0)
+            this.ensureTimerRunning();
+    }
+}
+export const createMessageScheduler = (sendMessage, options) => new MessageScheduler(sendMessage, options);

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(opts1: { [key: string]: any; 
+    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;
+    identityKey: any;
+    signedPreKey: {
+        keyId: number;
+        publicKey: any;
+        signature: any;
+    };
+    preKey: {
+        keyId: number;
+        publicKey: any;
+    };
+};
+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(opts2: { [key: string]: any; 
+    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: "@s.whatsapp.net";
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: any;
+        }[];
+    };
+}>;

package/lib/Utils/signal.js

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

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;
+    };
+};