zapo-js 0.1.0

package/dist/client/incoming.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIncomingBaseEvent = createIncomingBaseEvent;
+exports.createIncomingReceiptHandler = createIncomingReceiptHandler;
+exports.createIncomingFailureHandler = createIncomingFailureHandler;
+exports.createIncomingNotificationHandler = createIncomingNotificationHandler;
+exports.createIncomingGroupNotificationHandler = createIncomingGroupNotificationHandler;
+exports.createInfoBulletinNotificationEvent = createInfoBulletinNotificationEvent;
+exports.createUnhandledIncomingNodeEvent = createUnhandledIncomingNodeEvent;
+const group_1 = require("./events/group");
+const constants_1 = require("../protocol/constants");
+const message_1 = require("../transport/node/builders/message");
+const pairing_1 = require("../transport/node/builders/pairing");
+const helpers_1 = require("../transport/node/helpers");
+const parse_1 = require("../transport/stream/parse");
+const primitives_1 = require("../util/primitives");
+const LOGOUT_FAILURE_REASONS = new Set([401, 403, 406]);
+const DISCONNECT_FAILURE_REASONS = new Set([405, 409, 503]);
+const CORE_NOTIFICATION_TYPES = new Set([
+    'server_sync',
+    'picture',
+    'contacts',
+    'devices',
+    'disappearing_mode',
+    'mediaretry',
+    'encrypt',
+    'server',
+    'status',
+    'account_sync',
+    'privacy_token',
+    'newsletter',
+    'w:growth',
+    'registration',
+    'mex'
+]);
+const OUT_OF_SCOPE_NOTIFICATION_TYPES = new Set([
+    'business',
+    'pay',
+    'psa',
+    'waffle',
+    'hosted'
+]);
+function createIncomingBaseEvent(node) {
+    return {
+        rawNode: node,
+        stanzaId: node.attrs.id,
+        chatJid: node.attrs.from,
+        stanzaType: node.attrs.type
+    };
+}
+async function sendSafeAck(logger, sendNode, node) {
+    try {
+        await sendNode(node);
+    }
+    catch (error) {
+        logger.warn('failed to send inbound ack', {
+            tag: node.tag,
+            class: node.attrs.class,
+            type: node.attrs.type,
+            id: node.attrs.id,
+            message: (0, primitives_1.toError)(error).message
+        });
+    }
+}
+function classifyNotificationType(notificationType) {
+    if (CORE_NOTIFICATION_TYPES.has(notificationType)) {
+        return 'core';
+    }
+    if (OUT_OF_SCOPE_NOTIFICATION_TYPES.has(notificationType)) {
+        return 'out_of_scope';
+    }
+    return 'unknown';
+}
+async function applyFailureAction(options, reason, clearStoredCredentials) {
+    try {
+        await options.disconnect();
+        if (clearStoredCredentials) {
+            await options.clearStoredCredentials();
+        }
+    }
+    catch (error) {
+        options.logger.warn('failed applying failure stanza action', {
+            reason,
+            clearStoredCredentials,
+            message: (0, primitives_1.toError)(error).message
+        });
+    }
+}
+function createIncomingReceiptHandler(options) {
+    return async (node) => {
+        if (!node.attrs.id || !node.attrs.from) {
+            options.logger.warn('incoming receipt missing required attrs for ack', {
+                hasFrom: node.attrs.from !== undefined,
+                hasId: node.attrs.id !== undefined,
+                type: node.attrs.type
+            });
+            return true;
+        }
+        options.emitIncomingReceipt({
+            ...createIncomingBaseEvent(node),
+            participantJid: node.attrs.participant,
+            recipientJid: node.attrs.recipient
+        });
+        try {
+            await options.trackOutboundReceipt?.(node);
+        }
+        catch (error) {
+            options.logger.warn('failed to track outbound message receipt state', {
+                id: node.attrs.id,
+                from: node.attrs.from,
+                type: node.attrs.type,
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+        const receiptType = node.attrs.type;
+        if (receiptType === 'retry' || receiptType === 'enc_rekey_retry') {
+            if (options.handleIncomingRetryReceipt) {
+                await options.handleIncomingRetryReceipt(node);
+            }
+            else {
+                await sendSafeAck(options.logger, options.sendNode, (0, message_1.buildInboundRetryReceiptAckNode)(node));
+            }
+            return true;
+        }
+        await sendSafeAck(options.logger, options.sendNode, (0, message_1.buildInboundReceiptAckNode)(node));
+        return true;
+    };
+}
+function createIncomingFailureHandler(options) {
+    return async (node) => {
+        const reason = (0, parse_1.parseOptionalInt)(node.attrs.reason);
+        const code = (0, parse_1.parseOptionalInt)(node.attrs.code);
+        options.emitIncomingFailure({
+            ...createIncomingBaseEvent(node),
+            failureReason: reason,
+            failureCode: code,
+            failureMessage: node.attrs.message,
+            failureUrl: node.attrs.url
+        });
+        const shouldClearStoredCredentials = reason !== undefined && LOGOUT_FAILURE_REASONS.has(reason);
+        if (shouldClearStoredCredentials ||
+            (reason !== undefined && DISCONNECT_FAILURE_REASONS.has(reason))) {
+            await applyFailureAction(options, reason ?? 0, shouldClearStoredCredentials);
+        }
+        return true;
+    };
+}
+function createIncomingNotificationHandler(options) {
+    return async (node) => {
+        const notificationType = node.attrs.type ?? '';
+        const classification = classifyNotificationType(notificationType);
+        const firstChildTag = (0, helpers_1.getFirstNodeChild)(node)?.tag;
+        const serverSyncCollections = notificationType === 'server_sync'
+            ? (0, helpers_1.getNodeChildrenByTag)(node, constants_1.WA_NODE_TAGS.COLLECTION)
+                .map((collectionNode) => collectionNode.attrs.name)
+                .filter((name) => typeof name === 'string' && name.length > 0)
+            : [];
+        options.emitIncomingNotification({
+            ...createIncomingBaseEvent(node),
+            notificationType,
+            classification,
+            details: firstChildTag || serverSyncCollections.length > 0
+                ? {
+                    ...(firstChildTag ? { firstChildTag } : {}),
+                    ...(serverSyncCollections.length > 0
+                        ? { collections: serverSyncCollections }
+                        : {})
+                }
+                : undefined
+        });
+        if (classification === 'out_of_scope') {
+            options.emitUnhandledStanza({
+                ...createIncomingBaseEvent(node),
+                reason: `notification.${notificationType}.out_of_scope`
+            });
+        }
+        else if (classification === 'unknown') {
+            options.emitUnhandledStanza({
+                ...createIncomingBaseEvent(node),
+                reason: `notification.${notificationType || 'unknown'}.not_supported`
+            });
+        }
+        await sendSafeAck(options.logger, options.sendNode, (0, pairing_1.buildNotificationAckNode)(node));
+        if (notificationType === 'server_sync' && serverSyncCollections.length > 0) {
+            if (!options.syncAppState) {
+                options.logger.warn('received server_sync notification without app-state sync runtime', {
+                    collections: serverSyncCollections.join(',')
+                });
+                return true;
+            }
+            void options.syncAppState().catch((error) => {
+                options.logger.warn('failed to sync app-state after server_sync notification', {
+                    collections: serverSyncCollections.join(','),
+                    message: (0, primitives_1.toError)(error).message
+                });
+            });
+        }
+        return true;
+    };
+}
+function createIncomingGroupNotificationHandler(options) {
+    return async (node) => {
+        if (node.attrs.type !== constants_1.WA_NOTIFICATION_TYPES.GROUP) {
+            return false;
+        }
+        const parsed = (0, group_1.parseGroupNotificationEvents)(node);
+        for (const event of parsed.events) {
+            options.emitGroupEvent(event);
+        }
+        for (const unhandled of parsed.unhandled) {
+            options.emitUnhandledStanza(unhandled);
+        }
+        if (parsed.events.length === 0 && parsed.unhandled.length === 0) {
+            options.emitUnhandledStanza({
+                ...createIncomingBaseEvent(node),
+                reason: `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.empty`
+            });
+        }
+        await sendSafeAck(options.logger, options.sendNode, (0, pairing_1.buildNotificationAckNode)(node));
+        return true;
+    };
+}
+function createInfoBulletinNotificationEvent(node, type, details) {
+    return {
+        ...createIncomingBaseEvent(node),
+        notificationType: `ib.${type}`,
+        classification: 'info_bulletin',
+        details
+    };
+}
+function createUnhandledIncomingNodeEvent(node, reason = `unhandled.${node.tag}`) {
+    return {
+        ...createIncomingBaseEvent(node),
+        reason
+    };
+}

package/dist/client/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaClient = void 0;
+var WaClient_1 = require("./WaClient");
+Object.defineProperty(exports, "WaClient", { enumerable: true, get: function () { return WaClient_1.WaClient; } });

package/dist/client/mailbox.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistIncomingMailboxEntities = persistIncomingMailboxEntities;
+const _proto_1 = require("../proto.js");
+const primitives_1 = require("../util/primitives");
+async function persistContacts(contactStore, event, nowMs) {
+    const candidateJids = new Set();
+    if (event.senderJid) {
+        candidateJids.add(event.senderJid);
+    }
+    if (event.rawNode.attrs.participant) {
+        candidateJids.add(event.rawNode.attrs.participant);
+    }
+    await Promise.all(Array.from(candidateJids, (jid) => contactStore.upsert({ jid, lastUpdatedMs: nowMs })));
+}
+async function persistIncomingMailboxEntities(options) {
+    const { logger, contactStore, messageStore, event } = options;
+    const { stanzaId, chatJid } = event;
+    if (!stanzaId || !chatJid) {
+        return;
+    }
+    const nowMs = Date.now();
+    try {
+        const messageBytes = event.message
+            ? _proto_1.proto.Message.encode(event.message).finish()
+            : undefined;
+        await Promise.all([
+            messageStore.upsert({
+                id: stanzaId,
+                threadJid: chatJid,
+                senderJid: event.senderJid,
+                participantJid: event.rawNode.attrs.participant,
+                fromMe: false,
+                timestampMs: event.timestampSeconds === undefined ? undefined : event.timestampSeconds * 1000,
+                encType: event.encryptionType,
+                plaintext: event.plaintext,
+                messageBytes
+            }),
+            persistContacts(contactStore, event, nowMs)
+        ]);
+    }
+    catch (error) {
+        logger.warn('failed to persist incoming mailbox entities', {
+            id: stanzaId,
+            from: chatJid,
+            message: (0, primitives_1.toError)(error).message
+        });
+    }
+}

package/dist/client/messages.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMediaMessageContent = buildMediaMessageContent;
+exports.getMediaConn = getMediaConn;
+const conn_1 = require("../media/conn");
+const constants_1 = require("../media/constants");
+const WaMediaCrypto_1 = require("../media/WaMediaCrypto");
+const content_1 = require("../message/content");
+const constants_2 = require("../protocol/constants");
+const media_1 = require("../transport/node/builders/media");
+const base64_1 = require("../util/base64");
+const bytes_1 = require("../util/bytes");
+const primitives_1 = require("../util/primitives");
+async function buildMediaMessageContent(options, content) {
+    if (typeof content === 'string') {
+        return {
+            conversation: content
+        };
+    }
+    if ((0, content_1.isSendMediaMessage)(content)) {
+        return buildMediaMessage(options, content);
+    }
+    if (!content || typeof content !== 'object') {
+        throw new Error('invalid message content');
+    }
+    return content;
+}
+async function getMediaConn(options, forceRefresh = false) {
+    const cached = options.getMediaConnCache();
+    if (!forceRefresh && cached && Date.now() + constants_1.MEDIA_CONN_CACHE_GRACE_MS < cached.expiresAtMs) {
+        return cached;
+    }
+    const response = await options.queryWithContext('media_conn.fetch', (0, media_1.buildMediaConnIq)(), options.iqTimeoutMs ?? constants_2.WA_DEFAULTS.IQ_TIMEOUT_MS);
+    const mediaConn = (0, conn_1.parseMediaConnResponse)(response, Date.now());
+    options.setMediaConnCache(mediaConn);
+    return mediaConn;
+}
+async function buildMediaMessage(options, content) {
+    const mediaBytes = (0, bytes_1.toBytesView)(content.media);
+    const uploaded = await uploadMedia(options, content, mediaBytes);
+    const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
+    const common = {
+        url: uploaded.url,
+        mimetype: content.mimetype,
+        fileSha256: uploaded.fileSha256,
+        fileLength: mediaBytes.byteLength,
+        mediaKey: uploaded.mediaKey,
+        fileEncSha256: uploaded.fileEncSha256,
+        directPath: uploaded.directPath,
+        mediaKeyTimestamp
+    };
+    switch (content.type) {
+        case 'image':
+            return {
+                imageMessage: {
+                    ...common,
+                    caption: content.caption,
+                    width: content.width,
+                    height: content.height
+                }
+            };
+        case 'video':
+            return {
+                videoMessage: {
+                    ...common,
+                    caption: content.caption,
+                    gifPlayback: content.gifPlayback,
+                    seconds: content.seconds,
+                    width: content.width,
+                    height: content.height,
+                    metadataUrl: uploaded.metadataUrl
+                }
+            };
+        case 'audio':
+            return {
+                audioMessage: {
+                    ...common,
+                    seconds: content.seconds,
+                    ptt: content.ptt
+                }
+            };
+        case 'document':
+            return {
+                documentMessage: {
+                    ...common,
+                    caption: content.caption,
+                    fileName: content.fileName ?? 'file',
+                    title: content.fileName ?? undefined
+                }
+            };
+        case 'sticker':
+            return {
+                stickerMessage: {
+                    ...common,
+                    width: content.width,
+                    height: content.height
+                }
+            };
+        default:
+            throw new Error(`unsupported media type: ${content.type}`);
+    }
+}
+async function uploadMedia(options, content, mediaBytes) {
+    const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
+    const uploadType = content.type === 'video' && content.gifPlayback
+        ? 'gif'
+        : content.type === 'audio' && content.ptt
+            ? 'ptt'
+            : content.type;
+    const [encrypted, mediaConn] = await Promise.all([
+        WaMediaCrypto_1.WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes),
+        getMediaConn(options)
+    ]);
+    const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
+    const uploadPath = constants_1.MEDIA_UPLOAD_PATHS[uploadType];
+    const hashToken = (0, base64_1.bytesToBase64UrlSafe)(encrypted.fileEncSha256);
+    const uploadUrl = `https://${selectedHost}${uploadPath}/${hashToken}?auth=${encodeURIComponent(mediaConn.auth)}&token=${encodeURIComponent(hashToken)}`;
+    options.logger.debug('sending media upload request', {
+        mediaType: content.type,
+        uploadType,
+        host: selectedHost
+    });
+    const uploadResponse = await options.mediaTransfer.uploadStream({
+        url: uploadUrl,
+        method: 'POST',
+        body: encrypted.ciphertextHmac,
+        contentLength: encrypted.ciphertextHmac.byteLength,
+        contentType: content.mimetype
+    });
+    const uploadBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
+    if (!uploadResponse.ok) {
+        throw new Error(`media upload failed with status ${uploadResponse.status}`);
+    }
+    let parsedBody;
+    try {
+        parsedBody = JSON.parse(bytes_1.TEXT_DECODER.decode(uploadBody));
+    }
+    catch (error) {
+        throw new Error(`media upload returned invalid json: ${(0, primitives_1.toError)(error).message}`);
+    }
+    if (!parsedBody.url || !parsedBody.direct_path) {
+        throw new Error('media upload response missing url/direct_path');
+    }
+    return {
+        url: parsedBody.url,
+        directPath: parsedBody.direct_path,
+        mediaKey,
+        fileSha256: encrypted.fileSha256,
+        fileEncSha256: encrypted.fileEncSha256,
+        ...(parsedBody.metadata_url ? { metadataUrl: parsedBody.metadata_url } : {})
+    };
+}

package/dist/client/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/crypto/core/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERIALIZED_PUB_KEY_PREFIX = void 0;
+exports.SERIALIZED_PUB_KEY_PREFIX = 5;

package/dist/crypto/core/encoding.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64Url = decodeBase64Url;
+exports.assert32 = assert32;
+const bytes_1 = require("../../util/bytes");
+/**
+ * Base64 URL encoding utilities
+ */
+/**
+ * Decodes a base64url encoded string to Uint8Array
+ */
+function decodeBase64Url(value, field) {
+    if (!value) {
+        throw new Error(`missing ${field}`);
+    }
+    const padded = value
+        .replace(/-/g, '+')
+        .replace(/_/g, '/')
+        .padEnd(Math.ceil(value.length / 4) * 4, '=');
+    return (0, bytes_1.base64ToBytes)(padded);
+}
+/**
+ * Asserts that a Uint8Array is exactly 32 bytes
+ */
+function assert32(value, name) {
+    if (value.length !== 32) {
+        throw new Error(`${name} must be 32 bytes`);
+    }
+}

package/dist/crypto/core/hkdf.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hkdf = hkdf;
+exports.hkdfSplit = hkdfSplit;
+const node_crypto_1 = require("node:crypto");
+const bytes_1 = require("../../util/bytes");
+/**
+ * HKDF key derivation using SHA-256
+ */
+async function hkdf(ikm, salt, info, outLength) {
+    const key = await node_crypto_1.webcrypto.subtle.importKey('raw', ikm, 'HKDF', false, ['deriveBits']);
+    const bits = await node_crypto_1.webcrypto.subtle.deriveBits({
+        name: 'HKDF',
+        hash: 'SHA-256',
+        salt: salt ?? bytes_1.EMPTY_BYTES,
+        info: typeof info === 'string' ? bytes_1.TEXT_ENCODER.encode(info) : info
+    }, key, outLength * 8);
+    return (0, bytes_1.toBytesView)(bits);
+}
+/**
+ * HKDF key derivation that outputs two 32-byte keys
+ */
+async function hkdfSplit(ikm, salt, info) {
+    const out = await hkdf(ikm, salt, info, 64);
+    return [out.subarray(0, 32), out.subarray(32, 64)];
+}

package/dist/crypto/core/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Cryptographic utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519VerifyRaw = exports.aesCtrDecrypt = exports.aesCtrEncrypt = exports.pbkdf2DeriveAesCtrKey = exports.hmacSign = exports.importHmacSha512Key = exports.importHmacKey = exports.aesCbcDecrypt = exports.aesCbcEncrypt = exports.importAesCbcKey = exports.aesGcmDecrypt = exports.aesGcmEncrypt = exports.importAesGcmKey = exports.sha512 = exports.sha256 = exports.sha1 = exports.randomIntAsync = exports.randomBytesAsync = exports.buildNonce = exports.readVersionedContent = exports.prependVersion = exports.toRawPubKey = exports.toSerializedPubKey = exports.hkdfSplit = exports.hkdf = exports.assert32 = exports.decodeBase64Url = exports.X25519 = exports.Ed25519 = void 0;
+var Ed25519_1 = require("../curves/Ed25519");
+Object.defineProperty(exports, "Ed25519", { enumerable: true, get: function () { return Ed25519_1.Ed25519; } });
+var X25519_1 = require("../curves/X25519");
+Object.defineProperty(exports, "X25519", { enumerable: true, get: function () { return X25519_1.X25519; } });
+var encoding_1 = require("../core/encoding");
+Object.defineProperty(exports, "decodeBase64Url", { enumerable: true, get: function () { return encoding_1.decodeBase64Url; } });
+Object.defineProperty(exports, "assert32", { enumerable: true, get: function () { return encoding_1.assert32; } });
+var hkdf_1 = require("../core/hkdf");
+Object.defineProperty(exports, "hkdf", { enumerable: true, get: function () { return hkdf_1.hkdf; } });
+Object.defineProperty(exports, "hkdfSplit", { enumerable: true, get: function () { return hkdf_1.hkdfSplit; } });
+var keys_1 = require("../core/keys");
+Object.defineProperty(exports, "toSerializedPubKey", { enumerable: true, get: function () { return keys_1.toSerializedPubKey; } });
+Object.defineProperty(exports, "toRawPubKey", { enumerable: true, get: function () { return keys_1.toRawPubKey; } });
+Object.defineProperty(exports, "prependVersion", { enumerable: true, get: function () { return keys_1.prependVersion; } });
+Object.defineProperty(exports, "readVersionedContent", { enumerable: true, get: function () { return keys_1.readVersionedContent; } });
+var nonce_1 = require("../core/nonce");
+Object.defineProperty(exports, "buildNonce", { enumerable: true, get: function () { return nonce_1.buildNonce; } });
+var random_1 = require("../core/random");
+Object.defineProperty(exports, "randomBytesAsync", { enumerable: true, get: function () { return random_1.randomBytesAsync; } });
+Object.defineProperty(exports, "randomIntAsync", { enumerable: true, get: function () { return random_1.randomIntAsync; } });
+var primitives_1 = require("../core/primitives");
+Object.defineProperty(exports, "sha1", { enumerable: true, get: function () { return primitives_1.sha1; } });
+Object.defineProperty(exports, "sha256", { enumerable: true, get: function () { return primitives_1.sha256; } });
+Object.defineProperty(exports, "sha512", { enumerable: true, get: function () { return primitives_1.sha512; } });
+Object.defineProperty(exports, "importAesGcmKey", { enumerable: true, get: function () { return primitives_1.importAesGcmKey; } });
+Object.defineProperty(exports, "aesGcmEncrypt", { enumerable: true, get: function () { return primitives_1.aesGcmEncrypt; } });
+Object.defineProperty(exports, "aesGcmDecrypt", { enumerable: true, get: function () { return primitives_1.aesGcmDecrypt; } });
+Object.defineProperty(exports, "importAesCbcKey", { enumerable: true, get: function () { return primitives_1.importAesCbcKey; } });
+Object.defineProperty(exports, "aesCbcEncrypt", { enumerable: true, get: function () { return primitives_1.aesCbcEncrypt; } });
+Object.defineProperty(exports, "aesCbcDecrypt", { enumerable: true, get: function () { return primitives_1.aesCbcDecrypt; } });
+Object.defineProperty(exports, "importHmacKey", { enumerable: true, get: function () { return primitives_1.importHmacKey; } });
+Object.defineProperty(exports, "importHmacSha512Key", { enumerable: true, get: function () { return primitives_1.importHmacSha512Key; } });
+Object.defineProperty(exports, "hmacSign", { enumerable: true, get: function () { return primitives_1.hmacSign; } });
+Object.defineProperty(exports, "pbkdf2DeriveAesCtrKey", { enumerable: true, get: function () { return primitives_1.pbkdf2DeriveAesCtrKey; } });
+Object.defineProperty(exports, "aesCtrEncrypt", { enumerable: true, get: function () { return primitives_1.aesCtrEncrypt; } });
+Object.defineProperty(exports, "aesCtrDecrypt", { enumerable: true, get: function () { return primitives_1.aesCtrDecrypt; } });
+Object.defineProperty(exports, "ed25519VerifyRaw", { enumerable: true, get: function () { return primitives_1.ed25519VerifyRaw; } });

package/dist/crypto/core/keys.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSerializedPubKey = toSerializedPubKey;
+exports.toRawPubKey = toRawPubKey;
+exports.versionByte = versionByte;
+exports.prependVersion = prependVersion;
+exports.readVersionedContent = readVersionedContent;
+const constants_1 = require("../core/constants");
+/**
+ * Converts a 32-byte raw public key to 33-byte serialized format (with 0x05 prefix)
+ */
+function toSerializedPubKey(key) {
+    if (key.length === 33) {
+        if (key[0] !== constants_1.SERIALIZED_PUB_KEY_PREFIX) {
+            throw new Error('invalid serialized signal public key prefix');
+        }
+        return key;
+    }
+    if (key.length !== 32) {
+        throw new Error(`invalid signal public key length ${key.length}`);
+    }
+    const out = new Uint8Array(33);
+    out[0] = constants_1.SERIALIZED_PUB_KEY_PREFIX;
+    out.set(key, 1);
+    return out;
+}
+/**
+ * Converts a 33-byte serialized public key to 32-byte raw format
+ */
+function toRawPubKey(key) {
+    if (key.length === 32) {
+        return key;
+    }
+    if (key.length === 33 && key[0] === constants_1.SERIALIZED_PUB_KEY_PREFIX) {
+        return key.subarray(1);
+    }
+    throw new Error(`invalid signal public key length ${key.length}`);
+}
+/**
+ * Creates a version byte from high and low nibbles
+ */
+function versionByte(high, low) {
+    return ((high << 4) | low) & 0xff;
+}
+/**
+ * Prepends a version byte to content
+ */
+function prependVersion(content, version) {
+    const out = new Uint8Array(1 + content.length);
+    out[0] = versionByte(version, version);
+    out.set(content, 1);
+    return out;
+}
+/**
+ * Reads versioned content, validating the version and extracting the body
+ */
+function readVersionedContent(versionContent, expectedVersion, suffixLength) {
+    if (versionContent.length < 1) {
+        throw new Error('signal versioned content is empty');
+    }
+    const version = versionContent[0] >>> 4;
+    if (version !== expectedVersion) {
+        if (version < expectedVersion) {
+            throw new Error('legacy signal version');
+        }
+        throw new Error(`unsupported signal version ${version}`);
+    }
+    const bodyEnd = versionContent.length - suffixLength;
+    if (bodyEnd <= 1) {
+        throw new Error('invalid signal content length');
+    }
+    return versionContent.subarray(1, bodyEnd);
+}

package/dist/crypto/core/nonce.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNonce = buildNonce;
+/**
+ * Builds a 12-byte nonce for AES-GCM encryption with counter in the last 4 bytes.
+ * Throws if counter exceeds uint32 range to prevent nonce reuse.
+ */
+function buildNonce(counter) {
+    if (counter > 0xffffffff) {
+        throw new Error('nonce counter overflow: exceeds uint32 range');
+    }
+    const nonce = new Uint8Array(12);
+    nonce[8] = (counter >>> 24) & 0xff;
+    nonce[9] = (counter >>> 16) & 0xff;
+    nonce[10] = (counter >>> 8) & 0xff;
+    nonce[11] = counter & 0xff;
+    return nonce;
+}