@mrlegendbot/baileys 1.2.5 → 1.2.7

package/lib/Utils/signal.d.ts

@@ -0,0 +1,47 @@
+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 extractE2ESessionFromRetryReceipt: (receipt: BinaryNode) => {
+    registrationId: number;
+    identityKey: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
+    signedPreKey: {
+        keyId: number;
+        publicKey: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
+        signature: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
+    };
+    preKey: {
+        keyId: number;
+        publicKey: Uint8Array;
+    } | undefined;
+} | null;
+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

@@ -3,246 +3,199 @@ import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getB
 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;
+    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)
-  };
+    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 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();
+    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]
-  };
+    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',
+export const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
     attrs: {},
-    content: key.signature
-  }]
+    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',
+    tag: 'key',
     attrs: {},
-    content: encodeBigEndian(id, 3)
-  }, {
-    tag: 'value',
-    attrs: {},
-    content: pair.public
-  }]
+    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;
+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) };
     }
-    preKey = {
-      keyId: preKeyId,
-      publicKey: generateSignalPubKey(preKeyPub)
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: {
+            keyId: signedKeyId,
+            publicKey: generateSignalPubKey(signedPubKey),
+            signature: signedSig
+        },
+        preKey
     };
-  }
-  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);
-  }
-  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)
+    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) && (myUser !== user && myLid !== user || myDevice !== device) && (device === 0 || !!keyIndex)) {
-        if (isHosted) {
-          domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+    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)
+                });
+            }
         }
-        extracted.push({
-          user,
-          device,
-          domainType,
-          server: getServerFromDomainType(server, domainType)
-        });
-      }
     }
-  }
-  return extracted;
+    return extracted;
 };
-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
-  };
+/**
+ * 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
-  };
+    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,11 @@
+import type { BinaryNode } from '../WABinary/index.js';
+/**
+ * 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 declare function buildAckStanza(node: BinaryNode, errorCode?: number, meId?: string): BinaryNode;
+//# sourceMappingURL=stanza-ack.d.ts.map

package/lib/Utils/stanza-ack.js

@@ -1,30 +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
+    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 (errorCode) {
-    stanza.attrs.error = errorCode.toString();
-  }
-  if (attrs.participant) {
-    stanza.attrs.participant = attrs.participant;
-  }
-  if (attrs.recipient) {
-    stanza.attrs.recipient = attrs.recipient;
-  }
-  if (attrs.type) {
-    stanza.attrs.type = attrs.type;
-  }
-  if (tag === 'message' && meId) {
-    stanza.attrs.from = meId;
-  }
-  return stanza;
+    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/sync-action-utils.d.ts

@@ -0,0 +1,19 @@
+import { proto } from '../../WAProto/index.js';
+import type { BaileysEventEmitter, BaileysEventMap, Contact } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+export type ContactsUpsertResult = {
+    event: 'contacts.upsert';
+    data: Contact[];
+};
+export type LidMappingUpdateResult = {
+    event: 'lid-mapping.update';
+    data: BaileysEventMap['lid-mapping.update'];
+};
+export type SyncActionResult = ContactsUpsertResult | LidMappingUpdateResult;
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+export declare const processContactAction: (action: proto.SyncActionValue.IContactAction, id: string | undefined, logger?: ILogger) => SyncActionResult[];
+export declare const emitSyncActionResults: (ev: BaileysEventEmitter, results: SyncActionResult[]) => void;
+//# sourceMappingURL=sync-action-utils.d.ts.map

package/lib/Utils/sync-action-utils.js

@@ -1,45 +1,49 @@
-import { proto } from '../../WAProto/compiler.js';
+import { proto } from '../../WAProto/index.js';
 import { isLidUser, isPnUser } from '../WABinary/index.js';
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
 export const processContactAction = (action, id, logger) => {
-  const results = [];
-  if (!id) {
-    logger?.warn({
-      hasFullName: !!action.fullName,
-      hasLidJid: !!action.lidJid,
-      hasPnJid: !!action.pnJid
-    }, 'contactAction sync: missing id in index');
-    return results;
-  }
-  const lidJid = action.lidJid;
-  const idIsPn = isPnUser(id);
-  const phoneNumber = idIsPn ? id : action.pnJid || undefined;
-  results.push({
-    event: 'contacts.upsert',
-    data: [{
-      id,
-      name: action.fullName || action.firstName || action.username || undefined,
-      username: action.username || undefined,
-      lid: lidJid || undefined,
-      phoneNumber
-    }]
-  });
-  if (lidJid && isLidUser(lidJid) && idIsPn) {
+    const results = [];
+    if (!id) {
+        logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index');
+        return results;
+    }
+    const lidJid = action.lidJid;
+    const idIsPn = isPnUser(id);
+    // PN is in index[1], not in contactAction.pnJid which is usually null
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+    // Always emit contacts.upsert
     results.push({
-      event: 'lid-mapping.update',
-      data: {
-        lid: lidJid,
-        pn: id
-      }
+        event: 'contacts.upsert',
+        data: [
+            {
+                id,
+                name: action.fullName || action.firstName || action.username || undefined,
+                username: action.username || undefined,
+                lid: lidJid || undefined,
+                phoneNumber
+            }
+        ]
     });
-  }
-  return results;
+    // Emit lid-mapping.update if we have valid LID-PN pair
+    if (lidJid && isLidUser(lidJid) && idIsPn) {
+        results.push({
+            event: 'lid-mapping.update',
+            data: { lid: lidJid, pn: id }
+        });
+    }
+    return results;
 };
 export const emitSyncActionResults = (ev, results) => {
-  for (const result of results) {
-    if (result.event === 'contacts.upsert') {
-      ev.emit('contacts.upsert', result.data);
-    } else {
-      ev.emit('lid-mapping.update', result.data);
+    for (const result of results) {
+        if (result.event === 'contacts.upsert') {
+            ev.emit('contacts.upsert', result.data);
+        }
+        else {
+            ev.emit('lid-mapping.update', result.data);
+        }
     }
-  }
 };
+//# sourceMappingURL=sync-action-utils.js.map