ishumdz-bail 1.0.0

package/lib/Utils/rate-limiter.js

@@ -0,0 +1,228 @@
+/**
+ * RateLimiter — tracks outgoing message pacing per-socket to avoid sending
+ * patterns that look automated (fixed delays, bursts, identical repeated
+ * content). Call `getDelay()` before sending, `record()` after sending.
+ *
+ * This does not send anything or touch the socket itself — it's a pure,
+ * self-contained pacing calculator. Wire it into your own send path.
+ *
+ * Ported to ESM from a third-party fork's `antiban.js` (CommonJS). Logic is
+ * unchanged from the original — only the module syntax was converted.
+ */
+
+const TIME_CONSTANTS = {
+    MS_PER_SECOND: 1000,
+    MS_PER_MINUTE: 60000,
+    MS_PER_HOUR: 3600000,
+    MS_PER_DAY: 86400000,
+    BURST_RESET_MS: 30000,
+    IDENTICAL_WINDOW_MS: 3600000
+};
+
+const DEFAULT_CONFIG = {
+    maxPerMinute: 8,
+    maxPerHour: 200,
+    maxPerDay: 1500,
+    minDelayMs: 1500,
+    maxDelayMs: 5000,
+    newChatDelayMs: 3000,
+    maxIdenticalMessages: 3,
+    burstAllowance: 3,
+    identicalMessageWindowMs: TIME_CONSTANTS.IDENTICAL_WINDOW_MS
+};
+
+export class RateLimiter {
+    config;
+    messages = [];
+    identicalCount = new Map();
+    knownChats = new Set();
+    burstCount = 0;
+    lastMessageTime = 0;
+
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+
+    /**
+     * Returns how many ms to wait before sending, or -1 if this send should
+     * be blocked entirely (limit exceeded / too many identical messages).
+     */
+    async getDelay(recipient, content) {
+        const now = Date.now();
+        this.cleanup(now);
+        const contentHash = this.hashContent(content);
+
+        const dayMessages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_DAY);
+        if (dayMessages.length >= this.config.maxPerDay) {
+            return -1;
+        }
+
+        const hourMessages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_HOUR);
+        if (hourMessages.length >= this.config.maxPerHour) {
+            hourMessages.sort((a, b) => a.timestamp - b.timestamp);
+            const oldestInHour = hourMessages[0];
+            const delay2 = oldestInHour
+                ? oldestInHour.timestamp + TIME_CONSTANTS.MS_PER_HOUR - now
+                : TIME_CONSTANTS.MS_PER_HOUR;
+            return Math.max(delay2, TIME_CONSTANTS.MS_PER_MINUTE);
+        }
+
+        const minuteMessages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_MINUTE);
+        if (minuteMessages.length >= this.config.maxPerMinute) {
+            minuteMessages.sort((a, b) => a.timestamp - b.timestamp);
+            const oldestInMinute = minuteMessages[0];
+            const delay2 = oldestInMinute
+                ? oldestInMinute.timestamp + TIME_CONSTANTS.MS_PER_MINUTE - now
+                : TIME_CONSTANTS.MS_PER_MINUTE;
+            return Math.max(delay2, TIME_CONSTANTS.MS_PER_SECOND);
+        }
+
+        const tracker = this.identicalCount.get(contentHash);
+        if (tracker) {
+            if (now - tracker.firstSeen < this.config.identicalMessageWindowMs) {
+                if (tracker.count >= this.config.maxIdenticalMessages) {
+                    return -1;
+                }
+            }
+        }
+
+        let delay = 0;
+        if (this.burstCount < this.config.burstAllowance) {
+            this.burstCount++;
+            delay = this.jitter(this.config.minDelayMs * 0.5, this.config.minDelayMs);
+        }
+        else {
+            delay = this.jitter(this.config.minDelayMs, this.config.maxDelayMs);
+        }
+
+        const isInterop = recipient.endsWith('@interop');
+        if (!this.knownChats.has(recipient) || isInterop) {
+            delay += this.jitter(this.config.newChatDelayMs * 0.5, this.config.newChatDelayMs);
+        }
+
+        const timeSinceLast = now - this.lastMessageTime;
+        if (timeSinceLast < this.config.minDelayMs) {
+            delay = Math.max(delay, this.config.minDelayMs - timeSinceLast);
+        }
+
+        const typingDelay = Math.min(content.length * 30, 3000);
+        delay += this.jitter(typingDelay * 0.5, typingDelay);
+
+        return Math.round(delay);
+    }
+
+    /** Call this right after a message is actually sent. */
+    record(recipient, content) {
+        const now = Date.now();
+        // Guard against unbounded memory growth: cleanup() is normally
+        // triggered by getDelay(), but callers who only ever call record()
+        // (skipping getDelay(), e.g. only using this for stats) would never
+        // trim old entries otherwise. Cheap to check, only sweeps when the
+        // buffer has actually grown past a day's worth of entries.
+        if (this.messages.length > 0 && now - this.messages[0].timestamp > TIME_CONSTANTS.MS_PER_DAY) {
+            this.cleanup(now);
+        }
+        const contentHash = this.hashContent(content);
+        const timeSinceLast = now - this.lastMessageTime;
+        if (timeSinceLast > TIME_CONSTANTS.BURST_RESET_MS) {
+            this.burstCount = 0;
+        }
+        this.messages.push({ timestamp: now, recipient, contentHash });
+        this.knownChats.add(recipient);
+        this.lastMessageTime = now;
+
+        const tracker = this.identicalCount.get(contentHash);
+        if (tracker) {
+            if (now - tracker.firstSeen < this.config.identicalMessageWindowMs) {
+                tracker.count++;
+                tracker.lastSeen = now;
+            }
+            else {
+                this.identicalCount.set(contentHash, { count: 1, firstSeen: now, lastSeen: now });
+            }
+        }
+        else {
+            this.identicalCount.set(contentHash, { count: 1, firstSeen: now, lastSeen: now });
+        }
+    }
+
+    /**
+     * Combines getDelay() + record() into a single call so limits are
+     * respected correctly when queuing up several messages at once (e.g.
+     * `Promise.all(items.map(i => limiter.reserve(...)))` or a for-loop
+     * over a batch). Calling getDelay() alone multiple times before any
+     * record() will NOT see each other's pending sends — each call only
+     * "counts" once you actually record() it, so a batch processed via
+     * getDelay() first and record() second can burst past your configured
+     * limits. reserve() closes that gap by recording immediately, so each
+     * subsequent call in the same batch sees an up-to-date count.
+     *
+     * Returns -1 (same as getDelay) if the send should be blocked instead.
+     * Only record what you will actually send: if you decide not to send
+     * after getting a delay back, do not call reserve() for it.
+     */
+    async reserve(recipient, content) {
+        const delay = await this.getDelay(recipient, content);
+        if (delay === -1) {
+            return -1;
+        }
+        this.record(recipient, content);
+        return delay;
+    }
+
+    getStats() {
+        const now = Date.now();
+        this.cleanup(now);
+        return {
+            lastMinute: this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_MINUTE).length,
+            lastHour: this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_HOUR).length,
+            lastDay: this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_DAY).length,
+            limits: {
+                perMinute: this.config.maxPerMinute,
+                perHour: this.config.maxPerHour,
+                perDay: this.config.maxPerDay
+            },
+            knownChats: this.knownChats.size
+        };
+    }
+
+    getKnownChats() {
+        return this.knownChats;
+    }
+
+    /** Useful for restoring "known chat" state after a restart, so every
+     * chat isn't treated as brand-new (extra delay) after every reboot. */
+    restoreKnownChats(chats) {
+        for (const jid of chats) {
+            this.knownChats.add(jid);
+        }
+    }
+
+    cleanup(now) {
+        this.messages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_DAY);
+        for (const [hash, tracker] of this.identicalCount.entries()) {
+            if (now - tracker.lastSeen > this.config.identicalMessageWindowMs) {
+                this.identicalCount.delete(hash);
+            }
+        }
+    }
+
+    jitter(min, max) {
+        const u1 = Math.random();
+        const u2 = Math.random();
+        const normal = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+        const normalized = (normal + 3) / 6;
+        const clamped = Math.max(0, Math.min(1, normalized));
+        return Math.round(min + clamped * (max - min));
+    }
+
+    hashContent(content) {
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash |= 0;
+        }
+        return hash.toString(36);
+    }
+}

package/lib/Utils/reporting-utils.js

@@ -0,0 +1,258 @@
+import { createHmac } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { hkdf } from './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
+};
+export const shouldIncludeReportingToken = (message) => !message.reactionMessage &&
+    !message.encReactionMessage &&
+    !message.encEventResponseMessage &&
+    !message.pollUpdateMessage;
+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 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);
+};
+export 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 = createHmac('sha256', reportingSecret).update(content).digest().subarray(0, 16);
+    return {
+        tag: 'reporting',
+        attrs: {},
+        content: [
+            {
+                tag: 'reporting_token',
+                attrs: { v: '2' },
+                content: reportingToken
+            }
+        ]
+    };
+};
+//# sourceMappingURL=reporting-utils.js.map

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