zapo-js 0.1.0

package/dist/esm/transport/node/builders/message.js

@@ -0,0 +1,317 @@
+import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_NODE_TAGS } from '../../../protocol/constants.js';
+export function buildDirectMessageFanoutNode(input) {
+    if (input.participants.length === 0) {
+        throw new Error('direct message fanout requires at least one participant');
+    }
+    const attrs = {
+        to: input.to,
+        type: input.type
+    };
+    if (input.id) {
+        attrs.id = input.id;
+    }
+    const content = [
+        {
+            tag: WA_NODE_TAGS.PARTICIPANTS,
+            attrs: {},
+            content: input.participants.map((participant) => ({
+                tag: 'to',
+                attrs: {
+                    jid: participant.jid
+                },
+                content: [
+                    {
+                        tag: WA_MESSAGE_TAGS.ENC,
+                        attrs: {
+                            v: WA_MESSAGE_TYPES.ENC_VERSION,
+                            type: participant.encType
+                        },
+                        content: participant.ciphertext
+                    }
+                ]
+            }))
+        }
+    ];
+    if (input.deviceIdentity) {
+        content.push({
+            tag: WA_NODE_TAGS.DEVICE_IDENTITY,
+            attrs: {},
+            content: input.deviceIdentity
+        });
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.MESSAGE,
+        attrs,
+        content
+    };
+}
+export function buildGroupSenderKeyMessageNode(input) {
+    const attrs = {
+        to: input.to,
+        type: input.type
+    };
+    if (input.id) {
+        attrs.id = input.id;
+    }
+    if (input.phash) {
+        attrs.phash = input.phash;
+    }
+    if (input.addressingMode) {
+        attrs.addressing_mode = input.addressingMode;
+    }
+    const content = [];
+    if (input.participants.length > 0) {
+        content.push({
+            tag: WA_NODE_TAGS.PARTICIPANTS,
+            attrs: {},
+            content: input.participants.map((participant) => ({
+                tag: 'to',
+                attrs: {
+                    jid: participant.jid
+                },
+                content: [
+                    {
+                        tag: WA_MESSAGE_TAGS.ENC,
+                        attrs: {
+                            v: WA_MESSAGE_TYPES.ENC_VERSION,
+                            type: participant.encType
+                        },
+                        content: participant.ciphertext
+                    }
+                ]
+            }))
+        });
+    }
+    content.push({
+        tag: WA_MESSAGE_TAGS.ENC,
+        attrs: {
+            v: WA_MESSAGE_TYPES.ENC_VERSION,
+            type: 'skmsg'
+        },
+        content: input.groupCiphertext
+    });
+    if (input.deviceIdentity) {
+        content.push({
+            tag: WA_NODE_TAGS.DEVICE_IDENTITY,
+            attrs: {},
+            content: input.deviceIdentity
+        });
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.MESSAGE,
+        attrs,
+        content
+    };
+}
+export function buildGroupDirectMessageNode(input) {
+    if (input.participants.length === 0) {
+        throw new Error('group direct message requires at least one participant');
+    }
+    const attrs = {
+        to: input.to,
+        type: input.type
+    };
+    if (input.id) {
+        attrs.id = input.id;
+    }
+    if (input.phash) {
+        attrs.phash = input.phash;
+    }
+    if (input.addressingMode) {
+        attrs.addressing_mode = input.addressingMode;
+    }
+    const content = [
+        {
+            tag: WA_NODE_TAGS.PARTICIPANTS,
+            attrs: {},
+            content: input.participants.map((participant) => ({
+                tag: 'to',
+                attrs: {
+                    jid: participant.jid
+                },
+                content: [
+                    {
+                        tag: WA_MESSAGE_TAGS.ENC,
+                        attrs: {
+                            v: WA_MESSAGE_TYPES.ENC_VERSION,
+                            type: participant.encType
+                        },
+                        content: participant.ciphertext
+                    }
+                ]
+            }))
+        }
+    ];
+    if (input.deviceIdentity) {
+        content.push({
+            tag: WA_NODE_TAGS.DEVICE_IDENTITY,
+            attrs: {},
+            content: input.deviceIdentity
+        });
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.MESSAGE,
+        attrs,
+        content
+    };
+}
+export function buildInboundMessageAckNode(messageNode, id, to, meJid) {
+    const attrs = {
+        id,
+        to,
+        class: WA_MESSAGE_TYPES.ACK_CLASS_MESSAGE
+    };
+    if (messageNode.attrs.type) {
+        attrs.type = messageNode.attrs.type;
+    }
+    if (messageNode.attrs.participant) {
+        attrs.participant = messageNode.attrs.participant;
+    }
+    if (meJid) {
+        attrs.from = meJid;
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.ACK,
+        attrs
+    };
+}
+export function buildInboundDeliveryReceiptNode(messageNode, id, to) {
+    const attrs = {
+        id,
+        to
+    };
+    if (messageNode.attrs.participant) {
+        attrs.participant = messageNode.attrs.participant;
+    }
+    if (messageNode.attrs.category === 'peer') {
+        attrs.type = WA_MESSAGE_TYPES.RECEIPT_TYPE_PEER;
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.RECEIPT,
+        attrs
+    };
+}
+export function buildInboundRetryReceiptNode(messageNode, id, to, meJid, retryCount = 1) {
+    const attrs = {
+        id,
+        to,
+        type: 'retry'
+    };
+    if (messageNode.attrs.participant) {
+        attrs.participant = messageNode.attrs.participant;
+    }
+    if (meJid) {
+        attrs.from = meJid;
+    }
+    const normalizedRetryCount = Number.isSafeInteger(retryCount) && retryCount > 0 ? retryCount : 1;
+    const retryAttrs = {
+        count: String(normalizedRetryCount),
+        id
+    };
+    const timestamp = messageNode.attrs.t;
+    if (timestamp) {
+        retryAttrs.t = timestamp;
+        attrs.t = timestamp;
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.RECEIPT,
+        attrs,
+        content: [
+            {
+                tag: 'retry',
+                attrs: retryAttrs
+            }
+        ]
+    };
+}
+export function buildInboundRetryReceiptAckNode(receiptNode) {
+    const attrs = {
+        class: 'receipt',
+        type: 'retry'
+    };
+    if (receiptNode.attrs.id) {
+        attrs.id = receiptNode.attrs.id;
+    }
+    if (receiptNode.attrs.from) {
+        attrs.to = receiptNode.attrs.from;
+    }
+    if (receiptNode.attrs.participant) {
+        attrs.participant = receiptNode.attrs.participant;
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.ACK,
+        attrs
+    };
+}
+export function buildInboundReceiptAckNode(receiptNode) {
+    const attrs = {
+        class: 'receipt'
+    };
+    if (receiptNode.attrs.id) {
+        attrs.id = receiptNode.attrs.id;
+    }
+    if (receiptNode.attrs.from) {
+        attrs.to = receiptNode.attrs.from;
+    }
+    if (receiptNode.attrs.type) {
+        attrs.type = receiptNode.attrs.type;
+    }
+    if (receiptNode.attrs.participant &&
+        (!receiptNode.attrs.from || receiptNode.attrs.participant !== receiptNode.attrs.from)) {
+        attrs.participant = receiptNode.attrs.participant;
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.ACK,
+        attrs
+    };
+}
+export function buildGroupRetryMessageNode(input) {
+    const content = [
+        {
+            tag: WA_NODE_TAGS.PARTICIPANTS,
+            attrs: {},
+            content: [
+                {
+                    tag: 'to',
+                    attrs: { jid: input.requesterJid },
+                    content: [
+                        {
+                            tag: WA_MESSAGE_TAGS.ENC,
+                            attrs: {
+                                v: WA_MESSAGE_TYPES.ENC_VERSION,
+                                type: input.encType
+                            },
+                            content: input.ciphertext
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            tag: WA_MESSAGE_TAGS.ENC,
+            attrs: {
+                v: WA_MESSAGE_TYPES.ENC_VERSION,
+                type: 'skmsg'
+            },
+            content: undefined
+        }
+    ];
+    if (input.deviceIdentity) {
+        content.push({
+            tag: WA_NODE_TAGS.DEVICE_IDENTITY,
+            attrs: {},
+            content: input.deviceIdentity
+        });
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.MESSAGE,
+        attrs: {
+            to: input.to,
+            type: input.type,
+            id: input.id,
+            device_fanout: 'false',
+            addressing_mode: input.addressingMode
+        },
+        content
+    };
+}

package/dist/esm/transport/node/builders/pairing.js

@@ -0,0 +1,130 @@
+import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_SIGNALING, WA_XMLNS } from '../../../protocol/constants.js';
+const ZERO_BYTE = new Uint8Array([0]);
+const NOTIFICATION_CLASS = WA_NODE_TAGS.NOTIFICATION;
+export function buildCompanionHelloRequestNode(args) {
+    return {
+        tag: WA_NODE_TAGS.IQ,
+        attrs: {
+            to: WA_DEFAULTS.HOST_DOMAIN,
+            type: WA_IQ_TYPES.SET,
+            xmlns: WA_XMLNS.MD
+        },
+        content: [
+            {
+                tag: WA_NODE_TAGS.LINK_CODE_COMPANION_REG,
+                attrs: {
+                    jid: args.phoneJid,
+                    stage: WA_SIGNALING.LINK_CODE_STAGE_COMPANION_HELLO,
+                    should_show_push_notification: args.shouldShowPushNotification
+                        ? 'true'
+                        : 'false'
+                },
+                content: [
+                    {
+                        tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
+                        attrs: {},
+                        content: args.wrappedCompanionEphemeralPub
+                    },
+                    {
+                        tag: 'companion_server_auth_key_pub',
+                        attrs: {},
+                        content: args.companionServerAuthKeyPub
+                    },
+                    {
+                        tag: 'companion_platform_id',
+                        attrs: {},
+                        content: args.companionPlatformId
+                    },
+                    {
+                        tag: 'companion_platform_display',
+                        attrs: {},
+                        content: args.companionPlatformDisplay
+                    },
+                    {
+                        tag: 'link_code_pairing_nonce',
+                        attrs: {},
+                        content: ZERO_BYTE
+                    }
+                ]
+            }
+        ]
+    };
+}
+export function buildGetCountryCodeRequestNode() {
+    return {
+        tag: WA_NODE_TAGS.IQ,
+        attrs: {
+            to: WA_DEFAULTS.HOST_DOMAIN,
+            type: WA_IQ_TYPES.GET,
+            xmlns: WA_XMLNS.MD
+        },
+        content: [
+            {
+                tag: WA_NODE_TAGS.LINK_CODE_COMPANION_REG,
+                attrs: {
+                    stage: WA_SIGNALING.LINK_CODE_STAGE_GET_COUNTRY_CODE
+                }
+            }
+        ]
+    };
+}
+export function buildCompanionFinishRequestNode(args) {
+    return {
+        tag: WA_NODE_TAGS.IQ,
+        attrs: {
+            to: WA_DEFAULTS.HOST_DOMAIN,
+            type: WA_IQ_TYPES.SET,
+            xmlns: WA_XMLNS.MD
+        },
+        content: [
+            {
+                tag: WA_NODE_TAGS.LINK_CODE_COMPANION_REG,
+                attrs: {
+                    jid: args.phoneJid,
+                    stage: WA_SIGNALING.LINK_CODE_STAGE_COMPANION_FINISH
+                },
+                content: [
+                    {
+                        tag: 'link_code_pairing_wrapped_key_bundle',
+                        attrs: {},
+                        content: args.wrappedKeyBundle
+                    },
+                    {
+                        tag: 'companion_identity_public',
+                        attrs: {},
+                        content: args.companionIdentityPublic
+                    },
+                    {
+                        tag: WA_NODE_TAGS.LINK_CODE_PAIRING_REF,
+                        attrs: {},
+                        content: args.ref
+                    }
+                ]
+            }
+        ]
+    };
+}
+export function buildNotificationAckNode(node, typeOverride) {
+    const attrs = {
+        to: node.attrs.from ?? WA_DEFAULTS.HOST_DOMAIN,
+        class: NOTIFICATION_CLASS,
+        type: typeOverride ?? node.attrs.type ?? NOTIFICATION_CLASS
+    };
+    if (node.attrs.id) {
+        attrs.id = node.attrs.id;
+    }
+    return {
+        tag: WA_NODE_TAGS.ACK,
+        attrs
+    };
+}
+export function buildIqResultNode(iqNode) {
+    return {
+        tag: WA_NODE_TAGS.IQ,
+        attrs: {
+            ...(iqNode.attrs.id ? { id: iqNode.attrs.id } : {}),
+            to: iqNode.attrs.from ?? WA_DEFAULTS.HOST_DOMAIN,
+            type: WA_IQ_TYPES.RESULT
+        }
+    };
+}

package/dist/esm/transport/node/builders/prekeys.js

@@ -0,0 +1,102 @@
+import { WA_DEFAULTS, WA_NODE_TAGS, WA_XMLNS } from '../../../protocol/constants.js';
+import { SIGNAL_KEY_BUNDLE_TYPE_BYTES } from '../../../signal/api/constants.js';
+import { buildIqNode } from '../../node/query.js';
+import { intToBytes, toBytesView } from '../../../util/bytes.js';
+function buildSignedPreKeyNode(signedPreKey) {
+    return {
+        tag: WA_NODE_TAGS.SKEY,
+        attrs: {},
+        content: [
+            {
+                tag: WA_NODE_TAGS.ID,
+                attrs: {},
+                content: intToBytes(3, signedPreKey.keyId)
+            },
+            {
+                tag: WA_NODE_TAGS.VALUE,
+                attrs: {},
+                content: toBytesView(signedPreKey.keyPair.pubKey)
+            },
+            {
+                tag: WA_NODE_TAGS.SIGNATURE,
+                attrs: {},
+                content: toBytesView(signedPreKey.signature)
+            }
+        ]
+    };
+}
+export function buildPreKeyUploadIq(registrationInfo, signedPreKey, preKeys) {
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.SIGNAL, [
+        {
+            tag: WA_NODE_TAGS.REGISTRATION,
+            attrs: {},
+            content: intToBytes(4, registrationInfo.registrationId)
+        },
+        {
+            tag: WA_NODE_TAGS.TYPE,
+            attrs: {},
+            content: SIGNAL_KEY_BUNDLE_TYPE_BYTES
+        },
+        {
+            tag: WA_NODE_TAGS.IDENTITY,
+            attrs: {},
+            content: toBytesView(registrationInfo.identityKeyPair.pubKey)
+        },
+        {
+            tag: WA_NODE_TAGS.LIST,
+            attrs: {},
+            content: preKeys.map((record) => ({
+                tag: WA_NODE_TAGS.KEY,
+                attrs: {},
+                content: [
+                    {
+                        tag: WA_NODE_TAGS.ID,
+                        attrs: {},
+                        content: intToBytes(3, record.keyId)
+                    },
+                    {
+                        tag: WA_NODE_TAGS.VALUE,
+                        attrs: {},
+                        content: toBytesView(record.keyPair.pubKey)
+                    }
+                ]
+            }))
+        },
+        buildSignedPreKeyNode(signedPreKey)
+    ]);
+}
+export function buildSignedPreKeyRotateIq(signedPreKey) {
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.SIGNAL, [
+        {
+            tag: WA_NODE_TAGS.ROTATE,
+            attrs: {},
+            content: [buildSignedPreKeyNode(signedPreKey)]
+        }
+    ]);
+}
+export function buildMissingPreKeysFetchIq(users) {
+    return buildIqNode('get', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.SIGNAL, [
+        {
+            tag: WA_NODE_TAGS.KEY_FETCH,
+            attrs: {},
+            content: users.map((user) => ({
+                tag: WA_NODE_TAGS.USER,
+                attrs: {
+                    jid: user.userJid,
+                    ...(user.reasonIdentity === true ? { reason: 'identity' } : {})
+                },
+                content: user.devices.map((device) => ({
+                    tag: WA_NODE_TAGS.DEVICE,
+                    attrs: { id: String(device.deviceId) },
+                    content: [
+                        {
+                            tag: WA_NODE_TAGS.REGISTRATION,
+                            attrs: {},
+                            content: intToBytes(4, device.registrationId)
+                        }
+                    ]
+                }))
+            }))
+        }
+    ]);
+}

package/dist/esm/transport/node/builders/retry.js

@@ -0,0 +1,116 @@
+import { WA_MESSAGE_TAGS, WA_NODE_TAGS } from '../../../protocol/constants.js';
+import { RETRY_RECEIPT_VERSION } from '../../../retry/constants.js';
+import { SIGNAL_KEY_BUNDLE_TYPE_BYTES } from '../../../signal/api/constants.js';
+import { intToBytes } from '../../../util/bytes.js';
+function buildRetryKeysNode(keys) {
+    const content = [
+        {
+            tag: WA_NODE_TAGS.TYPE,
+            attrs: {},
+            content: SIGNAL_KEY_BUNDLE_TYPE_BYTES
+        },
+        {
+            tag: WA_NODE_TAGS.IDENTITY,
+            attrs: {},
+            content: keys.identity
+        },
+        {
+            tag: WA_NODE_TAGS.SKEY,
+            attrs: {},
+            content: [
+                {
+                    tag: WA_NODE_TAGS.ID,
+                    attrs: {},
+                    content: intToBytes(3, keys.skey.id)
+                },
+                {
+                    tag: WA_NODE_TAGS.VALUE,
+                    attrs: {},
+                    content: keys.skey.publicKey
+                },
+                {
+                    tag: WA_NODE_TAGS.SIGNATURE,
+                    attrs: {},
+                    content: keys.skey.signature
+                }
+            ]
+        }
+    ];
+    if (keys.key) {
+        content.push({
+            tag: WA_NODE_TAGS.KEY,
+            attrs: {},
+            content: [
+                {
+                    tag: WA_NODE_TAGS.ID,
+                    attrs: {},
+                    content: intToBytes(3, keys.key.id)
+                },
+                {
+                    tag: WA_NODE_TAGS.VALUE,
+                    attrs: {},
+                    content: keys.key.publicKey
+                }
+            ]
+        });
+    }
+    if (keys.deviceIdentity) {
+        content.push({
+            tag: WA_NODE_TAGS.DEVICE_IDENTITY,
+            attrs: {},
+            content: keys.deviceIdentity
+        });
+    }
+    return {
+        tag: 'keys',
+        attrs: {},
+        content
+    };
+}
+export function buildRetryReceiptNode(input) {
+    const attrs = {
+        id: input.stanzaId,
+        to: input.to,
+        type: 'retry'
+    };
+    if (input.participant) {
+        attrs.participant = input.participant;
+    }
+    if (input.recipient) {
+        attrs.recipient = input.recipient;
+    }
+    if (input.from) {
+        attrs.from = input.from;
+    }
+    if (input.categoryPeer) {
+        attrs.category = 'peer';
+    }
+    const retryAttrs = {
+        v: RETRY_RECEIPT_VERSION,
+        count: String(input.retryCount),
+        id: input.originalMsgId,
+        t: input.t
+    };
+    if (input.error !== undefined) {
+        retryAttrs.error = String(input.error);
+    }
+    const content = [
+        {
+            tag: 'retry',
+            attrs: retryAttrs
+        },
+        {
+            tag: WA_NODE_TAGS.REGISTRATION,
+            attrs: {},
+            content: intToBytes(4, input.registrationId)
+        }
+    ];
+    if (input.keys) {
+        content.push(buildRetryKeysNode(input.keys));
+    }
+    return {
+        tag: WA_MESSAGE_TAGS.RECEIPT,
+        attrs,
+        content
+    };
+}

package/dist/esm/transport/node/helpers.js

@@ -0,0 +1,37 @@
+import { base64ToBytes, TEXT_ENCODER } from '../../util/bytes.js';
+export function getNodeChildren(node) {
+    return Array.isArray(node.content) ? node.content : [];
+}
+export function findNodeChild(node, tag) {
+    return getNodeChildren(node).find((child) => child.tag === tag);
+}
+export function getFirstNodeChild(node) {
+    return getNodeChildren(node)[0];
+}
+export function getNodeChildrenByTag(node, tag) {
+    return getNodeChildren(node).filter((child) => child.tag === tag);
+}
+export function hasNodeChild(node, tag) {
+    return findNodeChild(node, tag) !== undefined;
+}
+export function decodeNodeContentUtf8OrBytes(value, field) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return TEXT_ENCODER.encode(value);
+    }
+    throw new Error(`node ${field} has no binary content`);
+}
+export function decodeNodeContentBase64OrBytes(value, field) {
+    if (value === null || value === undefined) {
+        throw new Error(`missing binary node content for ${field}`);
+    }
+    if (typeof value === 'string') {
+        return base64ToBytes(value);
+    }
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    throw new Error(`missing binary node content for ${field}`);
+}