@nerxa/socketon 0.0.0-stage → 1.21.0

package/src/Utils/signal.js

@@ -0,0 +1,193 @@
+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);
+    }
+
+    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;
+                }
+                extracted.push({
+                    user,
+                    device,
+                    domainType,
+                    server: getServerFromDomainType(server, domainType)
+                });
+            }
+        }
+    }
+    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 };
+};
+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/src/Utils/stanza-ack.d.ts

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

package/src/Utils/stanza-ack.js

@@ -0,0 +1,30 @@
+
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+}

package/src/Utils/status-stickers.d.ts

@@ -0,0 +1,127 @@
+import type { proto } from '../../WAProto/index.js';
+
+export declare const StatusLinkType: Readonly<{
+    RASTERIZED_LINK_PREVIEW: 1;
+    RASTERIZED_LINK_TRUNCATED: 2;
+    RASTERIZED_LINK_FULL_URL: 3;
+}>;
+
+export interface StickerArea {
+    /** Distance from the left edge, as a fraction of the media width. */
+    x: number;
+    /** Distance from the top edge, as a fraction of the media height. */
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare const STICKER_DEFAULT_AREA: Readonly<StickerArea>;
+
+export declare function stickerArea(area?: StickerArea): proto.IPoint[];
+
+export declare function locationSticker(options: {
+    latitude: number;
+    longitude: number;
+    name?: string;
+    area?: StickerArea | proto.IPoint[];
+    skipConfirmation?: boolean;
+}): proto.IInteractiveAnnotation;
+
+export declare function channelSticker(options: {
+    jid: string;
+    name?: string;
+    serverMessageId?: number;
+    accessibilityText?: string;
+    area?: StickerArea | proto.IPoint[];
+}): proto.IInteractiveAnnotation;
+
+export declare function linkSticker(options: {
+    url: string;
+    title?: string;
+    area?: StickerArea | proto.IPoint[];
+    linkType?: number;
+}): proto.IInteractiveAnnotation;
+
+export declare function musicSticker(options: {
+    songId?: string;
+    title?: string;
+    author?: string;
+    mediaId?: string;
+    artworkDirectPath?: string;
+    artworkSha256?: Buffer | string;
+    artworkEncSha256?: Buffer | string;
+    artworkMediaKey?: Buffer | string;
+    artistAttribution?: string;
+    countryBlocklist?: Buffer | string;
+    isExplicit?: boolean;
+    startTimeMs?: number;
+    derivedStartTimeMs?: number;
+    durationMs?: number;
+    area?: StickerArea | proto.IPoint[];
+}): proto.IInteractiveAnnotation;
+
+export declare function messageSticker(options: {
+    stanzaId?: string;
+    message: proto.IMessage;
+    area?: StickerArea | proto.IPoint[];
+}): proto.IInteractiveAnnotation;
+
+export declare function normalizeStickers(
+    stickers: proto.IInteractiveAnnotation | proto.IInteractiveAnnotation[]
+): proto.InteractiveAnnotation[];
+
+export interface ReadSticker {
+    kind: 'location' | 'channel' | 'link' | 'music' | 'message' | 'unknown';
+    area?: StickerArea;
+    location?: proto.ILocation;
+    channel?: proto.ContextInfo.IForwardedNewsletterMessageInfo;
+    link?: { url?: string; title?: string; linkType?: number };
+    music?: { songId?: string; title?: string; author?: string };
+    message?: proto.IEmbeddedMessage;
+    annotation: proto.IInteractiveAnnotation;
+}
+
+export declare function readStickers(message: any): ReadSticker[];
+
+export declare const MusicMessageStyle: Readonly<{ UNKNOWN: 0; VINYL: 1 }>;
+
+export interface MusicMessageOptions {
+    songId?: string;
+    mediaId?: string;
+    title?: string;
+    author?: string;
+    artistAttribution?: string;
+    artworkDirectPath?: string;
+    artworkSha256?: Buffer | string;
+    artworkEncSha256?: Buffer | string;
+    artworkMediaKey?: Buffer | string;
+    countryBlocklist?: Buffer | string;
+    isExplicit?: boolean;
+    startTimeMs?: number;
+    derivedStartTimeMs?: number;
+    durationMs?: number;
+    songUri?: string;
+    artworkUri?: string;
+    style?: number;
+    contextInfo?: proto.IContextInfo;
+}
+
+export declare function buildMusicMessage(options?: MusicMessageOptions): proto.Message.IMusicMessage;
+
+export declare function readMusicMessage(msg: any): {
+    songId?: string;
+    mediaId?: string;
+    title?: string;
+    author?: string;
+    artistAttribution?: string;
+    isExplicit?: boolean;
+    startTimeMs?: number | string;
+    durationMs?: number | string;
+    songUri?: string;
+    artworkUri?: string;
+    style?: number;
+    embeddedMusic: proto.IEmbeddedMusic;
+} | null;
+
+export declare const MUSIC_ALLOWED_HOSTS: readonly string[];
+export declare function isMusicHostAllowed(value?: unknown): boolean;

package/src/Utils/status-stickers.js

@@ -0,0 +1,260 @@
+import { proto } from '../../WAProto/index.js'
+
+export const StatusLinkType = Object.freeze({
+    RASTERIZED_LINK_PREVIEW: 1,
+    RASTERIZED_LINK_TRUNCATED: 2,
+    RASTERIZED_LINK_FULL_URL: 3
+})
+
+export const STICKER_DEFAULT_AREA = Object.freeze({ x: 0.25, y: 0.4, width: 0.5, height: 0.2 })
+
+const trimUndefined = (object) => {
+    for (const key of Object.keys(object)) {
+        if (object[key] === undefined) {
+            delete object[key]
+        }
+    }
+    return object
+}
+
+const fraction = (value, name) => {
+    const number = Number(value)
+    if (!Number.isFinite(number) || number < 0 || number > 1) {
+        throw new TypeError(`${name} must be between 0 and 1, the client reads these as a fraction of the media`)
+    }
+    return number
+}
+
+export const stickerArea = ({ x, y, width, height } = STICKER_DEFAULT_AREA) => {
+    const left = fraction(x, 'x')
+    const top = fraction(y, 'y')
+    const right = fraction(left + Number(width), 'x + width')
+    const bottom = fraction(top + Number(height), 'y + height')
+    if (right <= left || bottom <= top) {
+        throw new TypeError('a sticker area needs a positive width and height')
+    }
+    return [
+        { x: left, y: top },
+        { x: right, y: top },
+        { x: right, y: bottom },
+        { x: left, y: bottom }
+    ]
+}
+
+const annotation = (area, fields) => ({
+    polygonVertices: Array.isArray(area) ? area : stickerArea(area),
+    ...fields
+})
+
+export const locationSticker = ({ latitude, longitude, name, area, skipConfirmation } = {}) => {
+    const degreesLatitude = Number(latitude)
+    const degreesLongitude = Number(longitude)
+    if (!Number.isFinite(degreesLatitude) || !Number.isFinite(degreesLongitude)) {
+        throw new TypeError('locationSticker needs a numeric latitude and longitude')
+    }
+    return annotation(area, {
+        location: { degreesLatitude, degreesLongitude, ...(name ? { name } : {}) },
+        ...(skipConfirmation === undefined ? {} : { shouldSkipConfirmation: !!skipConfirmation })
+    })
+}
+
+export const channelSticker = ({ jid, name, serverMessageId = 0, accessibilityText, area } = {}) => {
+    if (typeof jid !== 'string' || !jid.endsWith('@newsletter')) {
+        throw new TypeError('channelSticker needs the channel jid, the one ending in @newsletter')
+    }
+    return annotation(area, {
+        newsletter: {
+            newsletterJid: jid,
+            serverMessageId: Number(serverMessageId),
+            ...(name ? { newsletterName: name } : {}),
+            ...(accessibilityText ? { accessibilityText } : {})
+        }
+    })
+}
+
+export const linkSticker = ({ url, title, area, linkType = StatusLinkType.RASTERIZED_LINK_PREVIEW } = {}) => {
+    if (typeof url !== 'string' || !url) {
+        throw new TypeError('linkSticker needs a url')
+    }
+    return annotation(area, {
+        tapAction: { tapUrl: url, ...(title ? { title } : {}) },
+        statusLinkType: linkType
+    })
+}
+
+export const musicSticker = ({
+    songId,
+    title,
+    author,
+    mediaId,
+    artworkDirectPath,
+    artworkSha256,
+    artworkEncSha256,
+    artworkMediaKey,
+    artistAttribution,
+    countryBlocklist,
+    isExplicit,
+    startTimeMs = 0,
+    derivedStartTimeMs,
+    durationMs,
+    area
+} = {}) => {
+    if (!songId && !mediaId) {
+        throw new TypeError('musicSticker needs at least a songId or a musicContentMediaId')
+    }
+    const bytes = value => (value === undefined ? undefined : Buffer.isBuffer(value) ? value : Buffer.from(value, 'base64'))
+    const embeddedMusic = {
+        ...(songId ? { songId: String(songId) } : {}),
+        ...(mediaId ? { musicContentMediaId: String(mediaId) } : {}),
+        ...(title ? { title } : {}),
+        ...(author ? { author } : {}),
+        ...(artistAttribution ? { artistAttribution } : {}),
+        ...(artworkDirectPath ? { artworkDirectPath } : {}),
+        ...(isExplicit === undefined ? {} : { isExplicit: !!isExplicit }),
+        musicSongStartTimeInMs: Number(startTimeMs),
+        ...(derivedStartTimeMs === undefined ? {} : { derivedContentStartTimeInMs: Number(derivedStartTimeMs) }),
+        ...(durationMs === undefined ? {} : { overlapDurationInMs: Number(durationMs) })
+    }
+    for (const [key, value] of [
+        ['artworkSha256', artworkSha256],
+        ['artworkEncSha256', artworkEncSha256],
+        ['artworkMediaKey', artworkMediaKey],
+        ['countryBlocklist', countryBlocklist]
+    ]) {
+        const buffer = bytes(value)
+        if (buffer) {
+            embeddedMusic[key] = buffer
+        }
+    }
+    return annotation(area, { embeddedContent: { embeddedMusic } })
+}
+
+export const messageSticker = ({ stanzaId, message, area } = {}) => {
+    if (!message) {
+        throw new TypeError('messageSticker needs the message it embeds')
+    }
+    return annotation(area, {
+        embeddedContent: { embeddedMessage: { ...(stanzaId ? { stanzaId } : {}), message } }
+    })
+}
+
+const ACTIONS = ['location', 'newsletter', 'embeddedAction', 'tapAction']
+
+export const normalizeStickers = (stickers) => {
+    const list = Array.isArray(stickers) ? stickers : [stickers]
+    return list.filter(Boolean).map((sticker, index) => {
+        const vertices = sticker.polygonVertices
+        if (!Array.isArray(vertices) || vertices.length !== 4) {
+            throw new TypeError(`sticker ${index} needs four polygonVertices, the client reads corner 0 and corner 2`)
+        }
+        const actions = ACTIONS.filter(name => sticker[name] !== undefined && sticker[name] !== null)
+        if (actions.length > 1) {
+            throw new TypeError(`sticker ${index} sets ${actions.join(' and ')}, but the client reads only one action per sticker`)
+        }
+        return proto.InteractiveAnnotation.fromObject(sticker)
+    })
+}
+
+export const readStickers = (message) => {
+    const media = message?.imageMessage ?? message?.videoMessage ?? message
+    const annotations = media?.interactiveAnnotations
+    if (!Array.isArray(annotations) || !annotations.length) {
+        return []
+    }
+    return annotations.map(item => {
+        const [topLeft, , bottomRight] = item.polygonVertices ?? []
+        const music = item.embeddedContent?.embeddedMusic
+        return {
+            kind: item.location
+                ? 'location'
+                : item.newsletter
+                    ? 'channel'
+                    : item.tapAction
+                        ? 'link'
+                        : music
+                            ? 'music'
+                            : item.embeddedContent?.embeddedMessage
+                                ? 'message'
+                                : 'unknown',
+            area: topLeft && bottomRight
+                ? { x: topLeft.x, y: topLeft.y, width: bottomRight.x - topLeft.x, height: bottomRight.y - topLeft.y }
+                : undefined,
+            location: item.location ?? undefined,
+            channel: item.newsletter ?? undefined,
+            link: item.tapAction ? { url: item.tapAction.tapUrl, title: item.tapAction.title, linkType: item.statusLinkType } : undefined,
+            music: music ? { songId: music.songId, title: music.title, author: music.author } : undefined,
+            message: item.embeddedContent?.embeddedMessage ?? undefined,
+            annotation: item
+        }
+    })
+}
+
+export const MusicMessageStyle = Object.freeze({ UNKNOWN: 0, VINYL: 1 })
+
+export const MUSIC_ALLOWED_HOSTS = Object.freeze([
+    '.whatsapp.net',
+    '.whatsapp.com',
+    '.fbcdn.net',
+    '.facebook.com',
+    '.instagram.com',
+    '.cdninstagram.com'
+])
+
+export const isMusicHostAllowed = (value) => {
+    let host
+    try {
+        host = new URL(String(value)).hostname.toLowerCase()
+    }
+    catch {
+        return false
+    }
+    return MUSIC_ALLOWED_HOSTS.some(suffix => host.endsWith(suffix) || host === suffix.slice(1))
+}
+
+const assertMusicHost = (value, label) => {
+    if (value === undefined) {
+        return undefined
+    }
+    if (!isMusicHostAllowed(value)) {
+        throw new TypeError(
+            `${label} must be hosted on ${MUSIC_ALLOWED_HOSTS.join(', ')} — the client refuses any other host `
+            + 'and draws nothing. Both uris come from Meta music catalog entries, so carry them over from a '
+            + 'message you received rather than pointing at your own file'
+        )
+    }
+    return value
+}
+
+const embeddedMusicOf = (options) => musicSticker(options).embeddedContent.embeddedMusic
+
+export const buildMusicMessage = ({ songUri, artworkUri, style = MusicMessageStyle.VINYL, contextInfo, ...music } = {}) =>
+    trimUndefined({
+        embeddedMusic: embeddedMusicOf(music),
+        songUri: assertMusicHost(songUri, 'songUri'),
+        artworkUri: assertMusicHost(artworkUri, 'artworkUri'),
+        style,
+        contextInfo
+    })
+
+export const readMusicMessage = (msg) => {
+    const message = msg?.message ?? msg
+    const music = message?.musicMessage
+    if (!music) {
+        return null
+    }
+    const embedded = music.embeddedMusic ?? {}
+    return {
+        songId: embedded.songId,
+        mediaId: embedded.musicContentMediaId,
+        title: embedded.title,
+        author: embedded.author,
+        artistAttribution: embedded.artistAttribution,
+        isExplicit: embedded.isExplicit,
+        startTimeMs: embedded.musicSongStartTimeInMs,
+        durationMs: embedded.overlapDurationInMs,
+        songUri: music.songUri,
+        artworkUri: music.artworkUri,
+        style: music.style,
+        embeddedMusic: embedded
+    }
+}

package/src/Utils/sync-action-utils.d.ts

@@ -0,0 +1,2 @@
+export function processContactAction(action: any, id: any, logger: any): any[];
+export function emitSyncActionResults(ev: any, results: any): void;

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

@@ -0,0 +1,44 @@
+import { isLidUser, isPnUser } from '../WABinary/index.js';
+
+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) {
+        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);
+        }
+    }
+};