jagproject 26.3.22 → 26.3.25

package/lib/Utils/reporting-utils.d.ts

@@ -0,0 +1,11 @@
+import { proto } from '../../WAProto/index.js';
+import type { WAMessageContent, WAMessageKey } from '../Types/index.js';
+import type { BinaryNode } from '../WABinary/index.js';
+export type ReportingField = {
+    f: number;
+    m?: boolean;
+    s?: ReportingField[];
+};
+export declare const shouldIncludeReportingToken: (message: proto.IMessage) => boolean;
+export declare const getMessageReportingToken: (msgProtobuf: Buffer, message: WAMessageContent, key: WAMessageKey) => Promise<BinaryNode | null>;
+//# sourceMappingURL=reporting-utils.d.ts.map

package/lib/Utils/reporting-utils.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0;
+const crypto_1 = require("crypto");
+const index_js_1 = require("../../WAProto/index.js");
+const crypto_js_1 = require("./crypto.js");
+const reportingFields = [
+    { f: 1 },
+    {
+        f: 3,
+        s: [{ f: 2 }, { f: 3 }, { f: 8 }, { f: 11 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 25 }]
+    },
+    { f: 4, s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 5, s: [{ f: 3 }, { f: 4 }, { f: 5 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 6, s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
+    { f: 7, s: [{ f: 2 }, { f: 7 }, { f: 10 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 8, s: [{ f: 2 }, { f: 7 }, { f: 9 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 21 }] },
+    { f: 9, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
+    { f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 26, s: [{ f: 4 }, { f: 5 }, { f: 8 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 28, s: [{ f: 1 }, { f: 2 }, { f: 4 }, { f: 5 }, { f: 6 }, { f: 7, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 37, s: [{ f: 1, m: true }] },
+    {
+        f: 49,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    { f: 53, s: [{ f: 1, m: true }] },
+    { f: 55, s: [{ f: 1, m: true }] },
+    { f: 58, s: [{ f: 1, m: true }] },
+    { f: 59, s: [{ f: 1, m: true }] },
+    {
+        f: 60,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    {
+        f: 64,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    { f: 66, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 74, s: [{ f: 1, m: true }] },
+    { f: 87, s: [{ f: 1, m: true }] },
+    { f: 88, s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 92, s: [{ f: 1, m: true }] },
+    { f: 93, s: [{ f: 1, m: true }] },
+    { f: 94, s: [{ f: 1, m: true }] }
+];
+const compileReportingFields = (fields) => {
+    const map = new Map();
+    for (const f of fields) {
+        map.set(f.f, {
+            m: f.m,
+            children: f.s ? compileReportingFields(f.s) : undefined
+        });
+    }
+    return map;
+};
+const compiledReportingFields = compileReportingFields(reportingFields);
+const EMPTY_MAP = new Map();
+const ENC_SECRET_REPORT_TOKEN = 'Report Token';
+const WIRE = {
+    VARINT: 0,
+    FIXED64: 1,
+    BYTES: 2,
+    FIXED32: 5
+};
+const shouldIncludeReportingToken = (message) => !message.reactionMessage &&
+    !message.encReactionMessage &&
+    !message.encEventResponseMessage &&
+    !message.pollUpdateMessage;
+exports.shouldIncludeReportingToken = shouldIncludeReportingToken;
+const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) => {
+    const useCaseSecret = Buffer.concat([
+        Buffer.from(origMsgId, 'utf8'),
+        Buffer.from(origMsgSender, 'utf8'),
+        Buffer.from(modificationSender, 'utf8'),
+        Buffer.from(modificationType, 'utf8')
+    ]);
+    return (0, crypto_js_1.hkdf)(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') });
+};
+const extractReportingTokenContent = (data, cfg) => {
+    const out = [];
+    let i = 0;
+    while (i < data.length) {
+        const tag = decodeVarint(data, i);
+        if (!tag.ok) {
+            return null;
+        }
+        const fieldNum = tag.value >> 3;
+        const wireType = tag.value & 0x7;
+        const fieldStart = i;
+        i += tag.bytes;
+        const fieldCfg = cfg.get(fieldNum);
+        const pushSlice = (end) => {
+            if (end > data.length) {
+                return false;
+            }
+            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) });
+            i = end;
+            return true;
+        };
+        const skip = (end) => {
+            if (end > data.length) {
+                return false;
+            }
+            i = end;
+            return true;
+        };
+        if (wireType === WIRE.VARINT) {
+            const v = decodeVarint(data, i);
+            if (!v.ok) {
+                return null;
+            }
+            const end = i + v.bytes;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.FIXED64) {
+            const end = i + 8;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.FIXED32) {
+            const end = i + 4;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.BYTES) {
+            const len = decodeVarint(data, i);
+            if (!len.ok) {
+                return null;
+            }
+            const valStart = i + len.bytes;
+            const valEnd = valStart + len.value;
+            if (valEnd > data.length) {
+                return null;
+            }
+            if (!fieldCfg) {
+                i = valEnd;
+                continue;
+            }
+            if (fieldCfg.m || fieldCfg.children) {
+                const sub = extractReportingTokenContent(data.subarray(valStart, valEnd), fieldCfg.children ?? EMPTY_MAP);
+                if (sub === null) {
+                    return null;
+                }
+                if (sub.length > 0) {
+                    const newTag = encodeVarint(tag.value);
+                    const newLen = encodeVarint(sub.length);
+                    out.push({
+                        num: fieldNum,
+                        bytes: Buffer.concat([newTag, newLen, sub])
+                    });
+                }
+                i = valEnd;
+                continue;
+            }
+            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) });
+            i = valEnd;
+            continue;
+        }
+        return null;
+    }
+    if (out.length === 0) {
+        return Buffer.alloc(0);
+    }
+    out.sort((a, b) => a.num - b.num);
+    return Buffer.concat(out.map(f => f.bytes));
+};
+const decodeVarint = (buffer, offset) => {
+    let value = 0;
+    let bytes = 0;
+    let shift = 0;
+    while (offset + bytes < buffer.length) {
+        const current = buffer[offset + bytes];
+        value |= (current & 0x7f) << shift;
+        bytes++;
+        if ((current & 0x80) === 0) {
+            return { value, bytes, ok: true };
+        }
+        shift += 7;
+        if (shift > 35) {
+            return { value: 0, bytes: 0, ok: false };
+        }
+    }
+    return { value: 0, bytes: 0, ok: false };
+};
+const encodeVarint = (value) => {
+    const parts = [];
+    let remaining = value >>> 0;
+    while (remaining > 0x7f) {
+        parts.push((remaining & 0x7f) | 0x80);
+        remaining >>>= 7;
+    }
+    parts.push(remaining);
+    return Buffer.from(parts);
+};
+const getMessageReportingToken = async (msgProtobuf, message, key) => {
+    const msgSecret = message.messageContextInfo?.messageSecret;
+    if (!msgSecret || !key.id) {
+        return null;
+    }
+    const from = key.fromMe ? key.remoteJid : key.participant || key.remoteJid;
+    const to = key.fromMe ? key.participant || key.remoteJid : key.remoteJid;
+    const reportingSecret = generateMsgSecretKey(ENC_SECRET_REPORT_TOKEN, key.id, from, to, msgSecret);
+    const content = extractReportingTokenContent(msgProtobuf, compiledReportingFields);
+    if (!content || content.length === 0) {
+        return null;
+    }
+    const reportingToken = (0, crypto_1.createHmac)('sha256', reportingSecret).update(content).digest().subarray(0, 16);
+    return {
+        tag: 'reporting',
+        attrs: {},
+        content: [
+            {
+                tag: 'reporting_token',
+                attrs: { v: '2' },
+                content: reportingToken
+            }
+        ]
+    };
+};
+exports.getMessageReportingToken = getMessageReportingToken;

package/lib/Utils/resolve-jid.d.ts

@@ -0,0 +1,43 @@
+import type { WASocket } from '../Types/index.js';
+
+/**
+ * Resolve LID / mention JID / participant ID menjadi JID @s.whatsapp.net.
+ *
+ * @param conn    WASocket instance
+ * @param m       serialized message object (dari handler)
+ * @param target  JID/LID eksplisit, opsional (override dari m)
+ * @returns       JID @s.whatsapp.net atau null jika tidak bisa di-resolve
+ *
+ * @example
+ * const jid = await resolveJid(conn, m);
+ * if (!jid) return conn.sendMessage(m.chat, { text: 'Gagal resolve JID' });
+ * await conn.sendMessage(m.chat, { text: `JID: ${jid}` });
+ *
+ * @example
+ * // Resolve dari mention pertama
+ * const jid = await resolveJid(conn, m, m.mentionedJid?.[0]);
+ */
+export declare function resolveJid(
+    conn: WASocket,
+    m: {
+        sender?: string;
+        jid?: string;
+        chat?: string;
+        isGroup?: boolean;
+        mentionedJid?: string[];
+        quoted?: { sender?: string; participant?: string };
+    },
+    target?: string | null
+): Promise<string | null>;
+
+/**
+ * Resolve banyak JID/LID sekaligus.
+ *
+ * @example
+ * const jids = await resolveJids(conn, m, m.mentionedJid);
+ */
+export declare function resolveJids(
+    conn: WASocket,
+    m: Parameters<typeof resolveJid>[1],
+    targets?: string[]
+): Promise<(string | null)[]>;

package/lib/Utils/resolve-jid.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * resolve-jid.js
+ * Resolve LID / participant ID menjadi JID WhatsApp asli (@s.whatsapp.net).
+ *
+ * Berguna saat participant.jid di grup adalah format @lid,
+ * dan kamu butuh nomor WA aslinya.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveJid = resolveJid;
+exports.resolveJids = resolveJids;
+const index_js_1 = require("../WABinary/index.js");
+/**
+ * Resolve LID, mention JID, atau sender menjadi JID @s.whatsapp.net.
+ *
+ * @param {import('../Types').WASocket} conn
+ * @param {object} m        — serialized message object
+ * @param {string} [target] — JID/LID eksplisit (opsional, override otomatis)
+ * @returns {Promise<string|null>}
+ *
+ * @example
+ * // Di dalam handler:
+ * const jid = await resolveJid(conn, m);
+ * if (!jid) return conn.sendMessage(m.chat, { text: 'Tidak bisa resolve JID' });
+ * await conn.sendMessage(m.chat, { text: `JID: ${jid}` });
+ *
+ * @example
+ * // Dengan target eksplisit (misalnya dari mention):
+ * const jid = await resolveJid(conn, m, m.mentionedJid?.[0]);
+ */
+async function resolveJid(conn, m, target) {
+    // Tentukan input — prioritas: target > mention > quoted sender > sender
+    const input = target ||
+        (m.mentionedJid && m.mentionedJid[0]) ||
+        (m.quoted && (m.quoted.sender || m.quoted.participant)) ||
+        m.sender ||
+        m.jid;
+    if (!input)
+        return null;
+    // Sudah berbentuk JID normal → langsung return
+    if (/@s\.whatsapp\.net$/.test(input)) {
+        return (0, index_js_1.jidNormalizedUser)(input);
+    }
+    // Jika bukan di grup, tidak bisa resolve LID via groupMetadata
+    if (!m.isGroup || !m.chat) {
+        // Coba normalise saja (untuk kasus user JID tanpa domain)
+        if (/^\d+$/.test(input.split('@')[0])) {
+            return `${input.split('@')[0]}@s.whatsapp.net`;
+        }
+        return null;
+    }
+    let meta;
+    try {
+        meta = await conn.groupMetadata(m.chat);
+    }
+    catch {
+        return null;
+    }
+    if (!meta || !Array.isArray(meta.participants))
+        return null;
+    // Cari match di participants: by jid, id, lid, atau user number
+    const inputUser = input.split('@')[0];
+    const participant = meta.participants.find(p => {
+        if (!p)
+            return false;
+        const pJid = p.jid || p.id || '';
+        const pLid = p.lid || '';
+        return (pJid === input ||
+            pLid === input ||
+            pJid.split('@')[0] === inputUser ||
+            pLid.split('@')[0] === inputUser);
+    });
+    if (participant) {
+        // Return JID yang sudah pasti @s.whatsapp.net
+        const resolved = participant.jid || participant.id;
+        if (resolved && /@s\.whatsapp\.net$/.test(resolved)) {
+            return (0, index_js_1.jidNormalizedUser)(resolved);
+        }
+    }
+    return null;
+}
+/**
+ * Resolve banyak JID/LID sekaligus.
+ *
+ * @param {import('../Types').WASocket} conn
+ * @param {object} m
+ * @param {string[]} targets
+ * @returns {Promise<(string|null)[]>}
+ *
+ * @example
+ * const jids = await resolveJids(conn, m, m.mentionedJid);
+ */
+async function resolveJids(conn, m, targets = []) {
+    return Promise.all(targets.map(t => resolveJid(conn, m, t)));
+}

package/lib/Utils/serial-task-queue.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SerialTaskQueue {
+    constructor(options = {}) {
+        this.concurrency = Math.max(1, Number(options.concurrency || 1));
+        this.running = 0;
+        this.queue = [];
+    }
+    add(task) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ task, resolve, reject });
+            this._drain();
+        });
+    }
+    _drain() {
+        while (this.running < this.concurrency && this.queue.length) {
+            const item = this.queue.shift();
+            this.running += 1;
+            Promise.resolve()
+                .then(() => item.task())
+                .then(value => item.resolve(value), error => item.reject(error))
+                .finally(() => {
+                this.running -= 1;
+                this._drain();
+            });
+        }
+    }
+}
+exports.default = SerialTaskQueue;

package/lib/Utils/signal.d.ts

@@ -0,0 +1,34 @@
+import type { SignalRepositoryWithLIDStore } from '../Types/index.js';
+import type { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth.js';
+import { type BinaryNode, type FullJid } from '../WABinary/index.js';
+import type { USyncQueryResultList } from '../WAUSync/index.js';
+export declare const createSignalIdentity: (wid: string, accountSignatureKey: Uint8Array) => SignalIdentity;
+export declare const getPreKeys: ({ get }: SignalKeyStore, min: number, limit: number) => Promise<{
+    [id: string]: KeyPair;
+}>;
+export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: number) => {
+    newPreKeys: {
+        [id: number]: KeyPair;
+    };
+    lastPreKeyId: number;
+    preKeysRange: readonly [number, number];
+};
+export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
+export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
+export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepositoryWithLIDStore) => Promise<void>;
+export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, myLid: string, excludeZeroDevices: boolean) => FullJid[];
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export declare const getNextPreKeys: ({ creds, keys }: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    preKeys: {
+        [id: string]: KeyPair;
+    };
+}>;
+export declare const getNextPreKeysNode: (state: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    node: BinaryNode;
+}>;
+//# sourceMappingURL=signal.d.ts.map

package/lib/Utils/signal.js

@@ -1,15 +1,21 @@
 "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 lodash_1 = require("lodash");
-const Defaults_1 = require("../Defaults");
-const WABinary_1 = require("../WABinary");
-const crypto_1 = require("./crypto");
-const generics_1 = require("./generics");
+const index_js_1 = require("../Defaults/index.js");
+const index_js_2 = require("../WABinary/index.js");
+const crypto_js_1 = require("./crypto.js");
+const generics_js_1 = require("./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;
+}
 const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
         identifier: { name: wid, deviceId: 0 },
-        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
+        identifierKey: (0, crypto_js_1.generateSignalPubKey)(accountSignatureKey)
     };
 };
 exports.createSignalIdentity = createSignalIdentity;
@@ -28,13 +34,13 @@ const generateOrGetPreKeys = (creds, range) => {
     const newPreKeys = {};
     if (remaining > 0) {
         for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = crypto_1.Curve.generateKeyPair();
+            newPreKeys[i] = crypto_js_1.Curve.generateKeyPair();
         }
     }
     return {
         newPreKeys,
         lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
     };
 };
 exports.generateOrGetPreKeys = generateOrGetPreKeys;
@@ -42,7 +48,7 @@ const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
+        { tag: 'id', attrs: {}, content: (0, generics_js_1.encodeBigEndian)(key.keyId, 3) },
         { tag: 'value', attrs: {}, content: key.keyPair.public },
         { tag: 'signature', attrs: {}, content: key.signature }
     ]
@@ -52,20 +58,22 @@ const xmppPreKey = (pair, id) => ({
     tag: 'key',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
+        { tag: 'id', attrs: {}, content: (0, generics_js_1.encodeBigEndian)(id, 3) },
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 });
 exports.xmppPreKey = xmppPreKey;
 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');
+    const extractKey = (key) => key
+        ? {
+            keyId: (0, index_js_2.getBinaryNodeChildUInt)(key, 'id', 3),
+            publicKey: (0, crypto_js_1.generateSignalPubKey)((0, index_js_2.getBinaryNodeChildBuffer)(key, 'value')),
+            signature: (0, index_js_2.getBinaryNodeChildBuffer)(key, 'signature')
+        }
+        : undefined;
+    const nodes = (0, index_js_2.getBinaryNodeChildren)((0, index_js_2.getBinaryNodeChild)(node, 'list'), 'user');
     for (const node of nodes) {
-        (0, WABinary_1.assertNodeErrorFree)(node);
+        (0, index_js_2.assertNodeErrorFree)(node);
     }
     // Most of the work in repository.injectE2ESession is CPU intensive, not IO
     // So Promise.all doesn't really help here,
@@ -73,42 +81,51 @@ const parseAndInjectE2ESessions = async (node, repository) => {
     // 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 = (0, lodash_1.chunk)(nodes, chunkSize);
+    const chunks = chunk(nodes, chunkSize);
     for (const nodesChunk of chunks) {
-        await Promise.all(nodesChunk.map(async (node) => {
-            const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
-            const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
-            const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
+        for (const node of nodesChunk) {
+            const signedKey = (0, index_js_2.getBinaryNodeChild)(node, 'skey');
+            const key = (0, index_js_2.getBinaryNodeChild)(node, 'key');
+            const identity = (0, index_js_2.getBinaryNodeChildBuffer)(node, 'identity');
             const jid = node.attrs.jid;
-            const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
+            const registrationId = (0, index_js_2.getBinaryNodeChildUInt)(node, 'registration', 4);
             await repository.injectE2ESession({
                 jid,
                 session: {
                     registrationId: registrationId,
-                    identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+                    identityKey: (0, crypto_js_1.generateSignalPubKey)(identity),
                     signedPreKey: extractKey(signedKey),
                     preKey: extractKey(key)
                 }
             });
-        }));
+        }
     }
 };
 exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
-const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
+const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = (0, index_js_2.jidDecode)(myJid);
     const extracted = [];
     for (const userResult of result) {
         const { devices, id } = userResult;
-        const { user } = (0, WABinary_1.jidDecode)(id);
-        const deviceList = devices === null || devices === void 0 ? void 0 : 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 });
+        const decoded = (0, index_js_2.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 === index_js_2.WAJIDDomains.LID ? index_js_2.WAJIDDomains.HOSTED_LID : index_js_2.WAJIDDomains.HOSTED;
                 }
+                extracted.push({
+                    user,
+                    device,
+                    domainType,
+                    server: (0, index_js_2.getServerFromDomainType)(server, domainType)
+                });
             }
         }
     }
@@ -138,11 +155,11 @@ const getNextPreKeysNode = async (state, count) => {
         attrs: {
             xmlns: 'encrypt',
             type: 'set',
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: index_js_2.S_WHATSAPP_NET
         },
         content: [
-            { tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
+            { tag: 'registration', attrs: {}, content: (0, generics_js_1.encodeBigEndian)(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: index_js_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)

package/lib/Utils/streamToBuffer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamToBuffer = streamToBuffer;
+const stream_1 = require("stream");
+/**
+ * Mengonversi Node.js Readable Stream menjadi Buffer.
+ * @param {Readable} stream Aliran data yang dapat dibaca.
+ * @returns {Promise<Buffer>} Promise yang diselesaikan dengan Buffer berisi semua data dari aliran.
+ */
+async function streamToBuffer(stream) {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream.on('data', chunk => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+        stream.on('error', reject);
+    });
+}