zapo-js 0.3.0 → 1.0.0

package/dist/esm/client/coordinators/WaStatusCoordinator.js

@@ -0,0 +1,46 @@
+import { proto } from '../../proto.js';
+import { WA_DEFAULTS } from '../../protocol/defaults.js';
+/** Builds a {@link WaStatusCoordinator} from its dependencies. */
+export function createStatusCoordinator(options) {
+    return {
+        setPrivacy: (input) => options.appStateMutations.setStatusPrivacy(input),
+        setUserMuted: (jid, muted) => options.appStateMutations.setUserStatusMute(jid, muted),
+        send: async (input) => {
+            const built = await options.buildMessageContent(input.content);
+            const message = built.message.conversation && !built.message.extendedTextMessage
+                ? {
+                    ...built.message,
+                    conversation: null,
+                    extendedTextMessage: {
+                        text: built.message.conversation
+                    }
+                }
+                : built.message;
+            const published = await options.publishStatusMessage({
+                message,
+                recipients: input.recipients,
+                statusSetting: input.statusSetting,
+                options: input.options
+            });
+            return built.upload ? { ...published, upload: built.upload } : published;
+        },
+        revokeStatus: async (input) => {
+            const message = {
+                protocolMessage: {
+                    type: proto.Message.ProtocolMessage.Type.REVOKE,
+                    key: {
+                        remoteJid: WA_DEFAULTS.STATUS_BROADCAST_JID,
+                        fromMe: true,
+                        id: input.messageId
+                    }
+                }
+            };
+            return options.publishStatusMessage({
+                message,
+                recipients: input.recipients,
+                statusSetting: input.statusSetting,
+                options: input.options
+            });
+        }
+    };
+}

package/dist/esm/client/coordinators/WaStreamControlCoordinator.js

@@ -82,7 +82,7 @@ export function createStreamControlHandler(options) {
     return {
         handleStreamControlResult: async (result) => {
             switch (result.kind) {
-                case 'xmlstreamend':
+                case WA_STREAM_SIGNALING.XML_STREAM_END_TAG:
                     logger.info('received xmlstreamend stanza');
                     return;
                 case 'stream_error_code':
@@ -99,23 +99,23 @@ export function createStreamControlHandler(options) {
                     }
                     await resumeSocketDueToStreamError(`stream_error_code_${result.code}`);
                     return;
-                case 'stream_error_replaced':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED:
                     logger.warn('received stream:error replaced, stopping client');
                     await disconnectDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED, null);
                     return;
-                case 'stream_error_device_removed':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED:
                     logger.warn('received stream:error device removed, logging out');
                     await logoutDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED, null, false);
                     return;
-                case 'stream_error_ack':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_ACK:
                     logger.warn('received stream:error ack', { id: result.id });
                     await resumeSocketDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_ACK);
                     return;
-                case 'stream_error_xml_not_well_formed':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_XML_NOT_WELL_FORMED:
                     logger.warn('received stream:error xml-not-well-formed');
                     await resumeSocketDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_XML_NOT_WELL_FORMED);
                     return;
-                case 'stream_error_other':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER:
                     logger.warn('received stream:error other');
                     await resumeSocketDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER);
                     return;

package/dist/esm/client/coordinators/WaTrustedContactTokenCoordinator.js

@@ -10,6 +10,7 @@ export class WaTrustedContactTokenCoordinator {
         this.logger = options.logger;
         this.store = options.store;
         this.runtime = options.runtime;
+        this.serverClock = options.serverClock;
         const maxDurationS = options.maxDurationS ?? WA_TC_TOKEN_DEFAULTS.MAX_DURATION_S;
         this.baseConfig = {
             durationS: clampDuration(options.durationS ?? WA_TC_TOKEN_DEFAULTS.DURATION_S, maxDurationS),
@@ -40,7 +41,7 @@ export class WaTrustedContactTokenCoordinator {
     }
     async resolveTokenForMessage(recipientJid) {
         const record = await this.store.getByJid(recipientJid);
-        const nowS = Math.floor(Date.now() / 1000);
+        const nowS = this.serverClock.nowSeconds();
         const config = this.resolveConfig();
         if (record?.tcToken &&
             record.tcTokenTimestamp !== undefined &&
@@ -51,11 +52,11 @@ export class WaTrustedContactTokenCoordinator {
         if (!nctSalt) {
             return null;
         }
-        const meLid = this.runtime.getCurrentMeLid();
+        const meLid = this.runtime.getCurrentCredentials()?.meLid;
         if (!meLid) {
             return null;
         }
-        const hash = await this.csTokenGenerator.generate(nctSalt, meLid);
+        const hash = this.csTokenGenerator.generate(nctSalt, meLid);
         return buildCsTokenMessageNode(hash);
     }
     async handleIncomingToken(fromJid, tokens) {
@@ -72,7 +73,7 @@ export class WaTrustedContactTokenCoordinator {
                 tcTokenTimestamp: token.timestampS,
                 updatedAtMs: nowMs
             });
-            this.runtime.emitEvent('privacy_token_update', {
+            this.runtime.emitEvent('debug_privacy_token', {
                 jid: fromJid,
                 timestampS: token.timestampS,
                 type: token.type,
@@ -82,7 +83,7 @@ export class WaTrustedContactTokenCoordinator {
     }
     async maybeIssueSenderToken(recipientJid) {
         return this.senderTokenDedup.run(recipientJid, async () => {
-            const nowS = Math.floor(Date.now() / 1000);
+            const nowS = this.serverClock.nowSeconds();
             const record = await this.store.getByJid(recipientJid);
             const senderTimestampS = record?.tcTokenSenderTimestamp;
             const config = this.resolveConfig();
@@ -104,7 +105,7 @@ export class WaTrustedContactTokenCoordinator {
         if (!record?.tcTokenSenderTimestamp) {
             return;
         }
-        const nowS = Math.floor(Date.now() / 1000);
+        const nowS = this.serverClock.nowSeconds();
         const config = this.resolveConfig();
         if (isTokenExpired(record.tcTokenSenderTimestamp, nowS, config.senderDurationS, config.senderNumBuckets)) {
             return;

package/dist/esm/client/events/appstate-mutation.js

@@ -0,0 +1,130 @@
+import { decodeEnumValue, decodeIndexArgsFromSchema, getAppstateSchemaByActionName } from '../../appstate-spec.js';
+export function parseAppStateMutationEvent(mutation) {
+    const parts = parseIndexParts(mutation.index);
+    if (!parts || parts.length === 0) {
+        return null;
+    }
+    const resolved = getAppstateSchemaByActionName(parts[0]);
+    if (!resolved) {
+        return null;
+    }
+    const indexArgs = decodeIndexArgsFromSchema(resolved.schema, parts);
+    if (!indexArgs) {
+        return null;
+    }
+    const valueRaw = mutation.value ?? null;
+    const base = {
+        source: mutation.source,
+        collection: mutation.collection,
+        version: mutation.version,
+        timestamp: mutation.timestamp,
+        _raw: { index: mutation.index, indexParts: parts, value: valueRaw }
+    };
+    if (mutation.operation === 'remove') {
+        return {
+            schema: resolved.key,
+            operation: 'remove',
+            ...indexArgs,
+            ...base
+        };
+    }
+    const data = unwrapData(resolved.schema, valueRaw);
+    return {
+        schema: resolved.key,
+        operation: 'set',
+        ...indexArgs,
+        ...(data ?? {}),
+        ...base
+    };
+}
+function unwrapData(schema, value) {
+    if (!value) {
+        return null;
+    }
+    const field = schema.valueField;
+    let inner;
+    if (field === null) {
+        const rest = {};
+        for (const key of Object.keys(value)) {
+            if (key === 'timestamp')
+                continue;
+            rest[key] = value[key];
+        }
+        inner = rest;
+    }
+    else {
+        const sub = value[field];
+        if (sub === null || sub === undefined || typeof sub !== 'object') {
+            return null;
+        }
+        inner = { ...sub };
+    }
+    applyEnumDecodeToData(schema.valueEnumFields, inner);
+    return inner;
+}
+function applyEnumDecodeToData(enumFields, data) {
+    if (!enumFields)
+        return;
+    for (const [fieldPath, enumPath] of Object.entries(enumFields)) {
+        applyDecodeAtPath(data, fieldPath.split('.'), (raw) => {
+            if (typeof raw !== 'number')
+                return raw;
+            const name = decodeEnumValue(enumPath, raw);
+            return name ?? raw;
+        });
+    }
+}
+function applyDecodeAtPath(obj, segments, transform) {
+    if (segments.length === 0)
+        return;
+    const [head, ...rest] = segments;
+    if (rest.length === 0) {
+        if (head in obj) {
+            const value = obj[head];
+            if (Array.isArray(value)) {
+                obj[head] = value.map(transform);
+            }
+            else if (value !== null && value !== undefined) {
+                obj[head] = transform(value);
+            }
+        }
+        return;
+    }
+    const next = obj[head];
+    if (Array.isArray(next)) {
+        for (const item of next) {
+            if (item && typeof item === 'object') {
+                applyDecodeAtPath(item, rest, transform);
+            }
+        }
+        return;
+    }
+    if (next && typeof next === 'object') {
+        applyDecodeAtPath(next, rest, transform);
+    }
+}
+function parseIndexParts(index) {
+    let parsed;
+    try {
+        parsed = JSON.parse(index);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(parsed)) {
+        return null;
+    }
+    const parts = [];
+    for (const item of parsed) {
+        if (typeof item === 'string') {
+            parts.push(item);
+            continue;
+        }
+        if (typeof item === 'number' || typeof item === 'boolean') {
+            parts.push(String(item));
+            continue;
+        }
+        return null;
+    }
+    return parts;
+}

package/dist/esm/client/events/business.js

@@ -0,0 +1,370 @@
+import { createUnhandledIncomingNodeEvent } from '../events/incoming.js';
+import { proto } from '../../proto.js';
+import { WA_BUSINESS_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from '../../protocol/constants.js';
+import { WA_NODE_TAGS } from '../../protocol/nodes.js';
+import { findNodeChild, getNodeChildren, getNodeChildrenByTag, getNodeTextContent } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+const VN_ISSUER_API = 'ent:wa';
+const VN_ISSUER_SMB = 'smb:wa';
+function parseCertificateContent(contentBytes) {
+    try {
+        const cert = proto.VerifiedNameCertificate.decode(contentBytes);
+        if (!cert.details)
+            return null;
+        const details = proto.VerifiedNameCertificate.Details.decode(cert.details);
+        return {
+            name: details.verifiedName ?? undefined,
+            serial: details.serial !== null && details.serial !== undefined
+                ? details.serial.toString()
+                : undefined,
+            isApi: details.issuer === VN_ISSUER_API,
+            isSmb: details.issuer === VN_ISSUER_SMB
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function parseVerifiedNameNode(node) {
+    if (node.tag !== WA_BUSINESS_NOTIFICATION_TAGS.VERIFIED_NAME)
+        return null;
+    const level = node.attrs.verified_level;
+    const attrSerial = node.attrs.serial;
+    const contentBytes = node.content instanceof Uint8Array ? node.content : undefined;
+    const certData = contentBytes !== undefined ? parseCertificateContent(contentBytes) : null;
+    const entry = {
+        name: certData?.name,
+        level,
+        serial: attrSerial ?? certData?.serial,
+        isApi: certData?.isApi === true,
+        isSmb: certData?.isSmb === true
+    };
+    const actualActors = node.attrs.actual_actors;
+    const hostStorage = node.attrs.host_storage;
+    const privacyModeTs = node.attrs.privacy_mode_ts;
+    if (actualActors !== undefined && hostStorage !== undefined && privacyModeTs !== undefined) {
+        entry.privacyMode = {
+            actualActors: Number.parseInt(actualActors, 10),
+            hostStorage: Number.parseInt(hostStorage, 10),
+            privacyModeTs: Number.parseInt(privacyModeTs, 10)
+        };
+    }
+    return entry;
+}
+function parseBusinessCategories(node) {
+    const children = getNodeChildren(node);
+    const categories = new Array(children.length);
+    let count = 0;
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== 'category')
+            continue;
+        const id = child.attrs.id;
+        if (!id)
+            continue;
+        categories[count] = { id, name: getNodeTextContent(child) ?? '' };
+        count += 1;
+    }
+    categories.length = count;
+    return categories;
+}
+function parseBusinessHoursNode(node) {
+    const timezone = node.attrs.timezone;
+    const children = getNodeChildren(node);
+    const config = new Array(children.length);
+    let count = 0;
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== 'business_hours_config')
+            continue;
+        const dayOfWeek = child.attrs.day_of_week;
+        const mode = child.attrs.mode;
+        if (!dayOfWeek || !mode)
+            continue;
+        const entry = { dayOfWeek, mode };
+        const openTime = child.attrs.open_time;
+        const closeTime = child.attrs.close_time;
+        if (openTime)
+            entry.openTime = Number.parseInt(openTime, 10);
+        if (closeTime)
+            entry.closeTime = Number.parseInt(closeTime, 10);
+        config[count] = entry;
+        count += 1;
+    }
+    config.length = count;
+    return { timezone, config };
+}
+function parseProfileOptions(node) {
+    const children = getNodeChildren(node);
+    const options = {};
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        const text = getNodeTextContent(child);
+        if (text !== undefined) {
+            options[child.tag] = text;
+        }
+    }
+    return options;
+}
+export function parseBusinessProfileNode(node) {
+    if (node.tag !== WA_BUSINESS_NOTIFICATION_TAGS.PROFILE)
+        return null;
+    const jid = node.attrs.jid;
+    if (!jid)
+        return null;
+    const entry = { jid };
+    const tag = node.attrs.tag;
+    if (tag)
+        entry.tag = tag;
+    const children = node.content;
+    if (!Array.isArray(children)) {
+        return entry;
+    }
+    const websites = [];
+    for (let j = 0; j < children.length; j += 1) {
+        const child = children[j];
+        const text = getNodeTextContent(child);
+        switch (child.tag) {
+            case 'description':
+                if (text !== undefined)
+                    entry.description = text;
+                break;
+            case 'address':
+                if (text !== undefined)
+                    entry.address = text;
+                break;
+            case 'email':
+                if (text !== undefined)
+                    entry.email = text;
+                break;
+            case 'website':
+                if (text !== undefined)
+                    websites.push({ url: text });
+                break;
+            case 'latitude':
+                if (text !== undefined) {
+                    const val = Number.parseFloat(text);
+                    if (!Number.isNaN(val))
+                        entry.latitude = val;
+                }
+                break;
+            case 'longitude':
+                if (text !== undefined) {
+                    const val = Number.parseFloat(text);
+                    if (!Number.isNaN(val))
+                        entry.longitude = val;
+                }
+                break;
+            case 'categories':
+                entry.categories = parseBusinessCategories(child);
+                break;
+            case 'business_hours':
+                entry.businessHours = parseBusinessHoursNode(child);
+                break;
+            case 'profile_options':
+                entry.profileOptions = parseProfileOptions(child);
+                break;
+        }
+    }
+    if (websites.length > 0)
+        entry.websites = websites;
+    return entry;
+}
+function parseSubscriptionsList(node) {
+    const subs = [];
+    for (const sub of getNodeChildrenByTag(node, 'subscription')) {
+        const id = sub.attrs.id;
+        const status = sub.attrs.status;
+        if (!id || !status)
+            continue;
+        subs.push({
+            id,
+            status,
+            tier: parseOptionalInt(sub.attrs.subscription_tier),
+            source: sub.attrs.source,
+            startTime: parseOptionalInt(sub.attrs.subscription_start_time),
+            creationTime: parseOptionalInt(sub.attrs.subscription_creation_time),
+            expirationDate: parseOptionalInt(sub.attrs.subscription_end_time)
+        });
+    }
+    return subs;
+}
+function parseFeatureFlagsList(node) {
+    const flags = [];
+    for (const flag of getNodeChildrenByTag(node, 'feature_flag')) {
+        const name = flag.attrs.name;
+        if (!name)
+            continue;
+        const enabled = (flag.attrs.enabled ?? '').toLowerCase() === 'true';
+        flags.push({
+            name,
+            enabled,
+            expirationTime: parseOptionalInt(flag.attrs.expiration_time),
+            limit: parseOptionalInt(flag.attrs.limit)
+        });
+    }
+    return flags;
+}
+function parseProductIds(catalogNode) {
+    const ids = [];
+    for (const product of getNodeChildrenByTag(catalogNode, 'product')) {
+        const idNode = findNodeChild(product, WA_NODE_TAGS.ID);
+        if (!idNode)
+            continue;
+        const text = getNodeTextContent(idNode);
+        if (text)
+            ids.push(text);
+    }
+    return ids;
+}
+function parseCollectionUpdates(catalogNode) {
+    const collections = [];
+    for (const collection of getNodeChildrenByTag(catalogNode, 'collection')) {
+        const id = collection.attrs.id;
+        if (!id)
+            continue;
+        const entry = { id };
+        const statusInfo = findNodeChild(collection, 'status_info');
+        if (statusInfo) {
+            const statusNode = findNodeChild(statusInfo, WA_NODE_TAGS.STATUS);
+            if (statusNode) {
+                const text = getNodeTextContent(statusNode);
+                if (text)
+                    entry.reviewStatus = text;
+            }
+            const rejectNode = findNodeChild(statusInfo, 'reject_reason');
+            if (rejectNode) {
+                const text = getNodeTextContent(rejectNode);
+                if (text)
+                    entry.rejectReason = text;
+            }
+            const commerceNode = findNodeChild(statusInfo, 'commerce_url');
+            if (commerceNode) {
+                const text = getNodeTextContent(commerceNode);
+                if (text)
+                    entry.commerceUrl = text;
+            }
+        }
+        collections.push(entry);
+    }
+    return collections;
+}
+function createBaseBusinessEvent(notificationNode) {
+    return {
+        rawNode: notificationNode,
+        stanzaId: notificationNode.attrs.id,
+        chatJid: notificationNode.attrs.from,
+        stanzaType: notificationNode.attrs.type,
+        offline: notificationNode.attrs.offline !== undefined,
+        timestampSeconds: parseOptionalInt(notificationNode.attrs.t)
+    };
+}
+function parseSingleBusinessEvent(notificationNode) {
+    const base = createBaseBusinessEvent(notificationNode);
+    const verifiedName = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.VERIFIED_NAME);
+    if (verifiedName) {
+        const vnJid = verifiedName.attrs.jid;
+        if (vnJid) {
+            const parsed = parseVerifiedNameNode(verifiedName);
+            if (!parsed)
+                return null;
+            return {
+                ...base,
+                action: 'verified_name_update',
+                bizJid: vnJid,
+                verifiedName: parsed
+            };
+        }
+        const vnHash = verifiedName.attrs.hash;
+        if (vnHash) {
+            return {
+                ...base,
+                action: 'verified_name_stale',
+                bizHash: vnHash
+            };
+        }
+        return null;
+    }
+    const remove = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.REMOVE);
+    if (remove) {
+        const rmJid = remove.attrs.jid;
+        if (rmJid) {
+            return { ...base, action: 'business_removed', bizJid: rmJid };
+        }
+        const rmHash = remove.attrs.hash;
+        if (rmHash) {
+            return { ...base, action: 'business_removed', bizHash: rmHash };
+        }
+        return null;
+    }
+    const profile = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.PROFILE);
+    if (profile) {
+        const hash = profile.attrs.hash;
+        if (hash) {
+            return { ...base, action: 'profile_update', bizHash: hash };
+        }
+        const fromJid = notificationNode.attrs.from;
+        return { ...base, action: 'profile_update', bizJid: fromJid };
+    }
+    const catalog = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.PRODUCT_CATALOG);
+    if (catalog) {
+        const fromJid = notificationNode.attrs.from;
+        if (findNodeChild(catalog, 'product')) {
+            return {
+                ...base,
+                action: 'product_update',
+                bizJid: fromJid,
+                productIds: parseProductIds(catalog)
+            };
+        }
+        if (findNodeChild(catalog, 'collection')) {
+            return {
+                ...base,
+                action: 'collection_update',
+                bizJid: fromJid,
+                collections: parseCollectionUpdates(catalog)
+            };
+        }
+        return null;
+    }
+    const subscriptions = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.SUBSCRIPTIONS);
+    const featureFlags = findNodeChild(notificationNode, WA_BUSINESS_NOTIFICATION_TAGS.FEATURE_FLAGS);
+    if (subscriptions || featureFlags) {
+        return {
+            ...base,
+            action: 'subscriptions_update',
+            bizJid: notificationNode.attrs.from,
+            subscriptions: subscriptions ? parseSubscriptionsList(subscriptions) : [],
+            featureFlags: featureFlags ? parseFeatureFlagsList(featureFlags) : []
+        };
+    }
+    return null;
+}
+export function parseBusinessNotificationEvents(notificationNode) {
+    if (notificationNode.tag !== WA_NODE_TAGS.NOTIFICATION ||
+        notificationNode.attrs.type !== WA_NOTIFICATION_TYPES.BUSINESS) {
+        return { events: [], unhandled: [] };
+    }
+    try {
+        const event = parseSingleBusinessEvent(notificationNode);
+        if (event) {
+            return { events: [event], unhandled: [] };
+        }
+        const firstChild = getNodeChildren(notificationNode)[0];
+        const childTag = firstChild?.tag ?? 'empty';
+        return {
+            events: [],
+            unhandled: [
+                createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.BUSINESS}.${childTag}.not_supported`)
+            ]
+        };
+    }
+    catch {
+        return {
+            events: [],
+            unhandled: [
+                createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.BUSINESS}.parse_failed`)
+            ]
+        };
+    }
+}

package/dist/esm/client/events/call.js

@@ -0,0 +1,55 @@
+import { WA_CALL_CHILD_TAGS, WA_CALL_NODE_ATTRS, WA_CALL_PAYLOAD_TAGS } from '../../protocol/call.js';
+import { findNodeChild, getFirstNodeChild, getNodeChildren, hasNodeChild } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+const KNOWN_CALL_PAYLOAD_TAGS = new Set(Object.values(WA_CALL_PAYLOAD_TAGS));
+function parseGroupInfo(node) {
+    const children = getNodeChildren(node);
+    if (children.length === 0) {
+        return undefined;
+    }
+    const out = [];
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        const jid = child.attrs.jid;
+        if (!jid)
+            continue;
+        out.push({
+            jid,
+            userPnJid: child.attrs[WA_CALL_NODE_ATTRS.USER_PN],
+            username: child.attrs[WA_CALL_NODE_ATTRS.USERNAME],
+            guestName: child.attrs[WA_CALL_NODE_ATTRS.GUEST_NAME]
+        });
+    }
+    return out.length > 0 ? out : undefined;
+}
+export function parseCallNode(node) {
+    const payload = getFirstNodeChild(node);
+    if (!payload) {
+        return { type: 'unknown', isVideo: false };
+    }
+    const payloadTag = payload.tag;
+    const type = KNOWN_CALL_PAYLOAD_TAGS.has(payloadTag)
+        ? payloadTag
+        : 'unknown';
+    const groupInfoNode = findNodeChild(payload, WA_CALL_CHILD_TAGS.GROUP_INFO);
+    const silenceNode = findNodeChild(payload, WA_CALL_CHILD_TAGS.SILENCE);
+    return {
+        type,
+        payloadTag,
+        callId: payload.attrs[WA_CALL_NODE_ATTRS.CALL_ID],
+        callCreatorJid: payload.attrs[WA_CALL_NODE_ATTRS.CALL_CREATOR],
+        senderLidJid: node.attrs[WA_CALL_NODE_ATTRS.SENDER_LID],
+        callerPnJid: payload.attrs[WA_CALL_NODE_ATTRS.CALLER_PN],
+        groupJid: payload.attrs[WA_CALL_NODE_ATTRS.GROUP_JID],
+        isVideo: hasNodeChild(payload, WA_CALL_CHILD_TAGS.VIDEO),
+        callerUsername: payload.attrs[WA_CALL_NODE_ATTRS.USERNAME],
+        callerCountryCode: payload.attrs[WA_CALL_NODE_ATTRS.CALLER_COUNTRY_CODE],
+        callerPushName: payload.attrs[WA_CALL_NODE_ATTRS.NOTIFY],
+        peerPlatform: node.attrs[WA_CALL_NODE_ATTRS.PLATFORM],
+        peerAppVersion: node.attrs[WA_CALL_NODE_ATTRS.VERSION],
+        timestampSeconds: parseOptionalInt(node.attrs.t),
+        endTimestampSeconds: parseOptionalInt(node.attrs.e),
+        silenceReason: silenceNode?.attrs[WA_CALL_NODE_ATTRS.REASON],
+        groupInfo: groupInfoNode ? parseGroupInfo(groupInfoNode) : undefined
+    };
+}