zapo-js 0.2.0 → 1.0.0

package/dist/esm/client/messages.js

@@ -1,224 +0,0 @@
-import { createReadStream } from 'node:fs';
-import { parseMediaConnResponse } from '../media/conn.js';
-import { MEDIA_CONN_CACHE_GRACE_MS, MEDIA_UPLOAD_PATHS } from '../media/constants.js';
-import { WaMediaCrypto } from '../media/WaMediaCrypto.js';
-import { isSendMediaMessage } from '../message/content.js';
-import { WA_DEFAULTS } from '../protocol/constants.js';
-import { buildMediaConnIq } from '../transport/node/builders/media.js';
-import { bytesToBase64UrlSafe, TEXT_DECODER, toBytesView } from '../util/bytes.js';
-import { toError } from '../util/primitives.js';
-export async function buildMediaMessageContent(options, content) {
-    if (typeof content === 'string') {
-        return {
-            conversation: content
-        };
-    }
-    if (isSendMediaMessage(content)) {
-        return buildMediaMessage(options, content);
-    }
-    if (!content || typeof content !== 'object') {
-        throw new Error('invalid message content');
-    }
-    return content;
-}
-export async function getMediaConn(options, forceRefresh = false) {
-    const cached = options.getMediaConnCache();
-    if (!forceRefresh && cached && Date.now() + MEDIA_CONN_CACHE_GRACE_MS < cached.expiresAtMs) {
-        return cached;
-    }
-    const response = await options.queryWithContext('media_conn.fetch', buildMediaConnIq(), options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS);
-    const mediaConn = parseMediaConnResponse(response, Date.now());
-    options.setMediaConnCache(mediaConn);
-    return mediaConn;
-}
-function resolveUploadType(content) {
-    if (content.type === 'video' && content.gifPlayback)
-        return 'gif';
-    if (content.type === 'audio' && content.ptt)
-        return 'ptt';
-    return content.type;
-}
-function isReadableStream(value) {
-    return (!!value &&
-        typeof value === 'object' &&
-        'pipe' in value &&
-        typeof value.pipe === 'function');
-}
-async function buildMediaMessage(options, content) {
-    const uploaded = isReadableStream(content.media)
-        ? await uploadMediaStream(options, content, content.media)
-        : await uploadMediaBytes(options, content, toBytesView(content.media));
-    const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
-    const common = {
-        url: uploaded.url,
-        mimetype: content.mimetype,
-        fileSha256: uploaded.fileSha256,
-        fileLength: uploaded.fileLength,
-        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 'ptv':
-            return {
-                ptvMessage: {
-                    ...common,
-                    seconds: content.seconds,
-                    width: content.width,
-                    height: content.height
-                }
-            };
-        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 message type: ${String(content.type)}`);
-    }
-}
-function buildUploadUrl(host, uploadType, auth, fileEncSha256) {
-    const hashToken = bytesToBase64UrlSafe(fileEncSha256);
-    const uploadPath = MEDIA_UPLOAD_PATHS[uploadType];
-    if (!uploadPath) {
-        throw new Error(`unknown media upload type: ${String(uploadType)}`);
-    }
-    return `https://${host}${uploadPath}/${hashToken}?auth=${encodeURIComponent(auth)}&token=${encodeURIComponent(hashToken)}`;
-}
-function parseUploadResponse(body, status) {
-    if (status < 200 || status >= 300) {
-        throw new Error(`media upload failed with status ${status}`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(TEXT_DECODER.decode(body));
-    }
-    catch (error) {
-        throw new Error(`media upload returned invalid json: ${toError(error).message}`);
-    }
-    if (!parsed.url || !parsed.direct_path) {
-        throw new Error('media upload response missing url/direct_path');
-    }
-    return {
-        url: parsed.url,
-        directPath: parsed.direct_path,
-        ...(parsed.metadata_url ? { metadataUrl: parsed.metadata_url } : {})
-    };
-}
-async function uploadMediaBytes(options, content, mediaBytes) {
-    const uploadType = resolveUploadType(content);
-    const mediaKey = await WaMediaCrypto.generateMediaKey();
-    const [encrypted, mediaConn] = await Promise.all([
-        WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes),
-        getMediaConn(options)
-    ]);
-    const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
-    const uploadUrl = buildUploadUrl(selectedHost, uploadType, mediaConn.auth, encrypted.fileEncSha256);
-    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 responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
-    const parsed = parseUploadResponse(responseBody, uploadResponse.status);
-    return {
-        ...parsed,
-        mediaKey,
-        fileSha256: encrypted.fileSha256,
-        fileEncSha256: encrypted.fileEncSha256,
-        fileLength: mediaBytes.byteLength
-    };
-}
-async function uploadMediaStream(options, content, stream) {
-    const uploadType = resolveUploadType(content);
-    const mediaKey = await WaMediaCrypto.generateMediaKey();
-    const encResult = await WaMediaCrypto.encryptToFile(uploadType, mediaKey, stream);
-    let readStream;
-    try {
-        const mediaConn = await getMediaConn(options);
-        const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ??
-            mediaConn.hosts[0].hostname;
-        const uploadUrl = buildUploadUrl(selectedHost, uploadType, mediaConn.auth, encResult.fileEncSha256);
-        options.logger.debug('sending media stream upload request', {
-            mediaType: content.type,
-            uploadType,
-            host: selectedHost,
-            encryptedSize: encResult.fileSize
-        });
-        readStream = createReadStream(encResult.filePath);
-        const uploadResponse = await options.mediaTransfer.uploadStream({
-            url: uploadUrl,
-            method: 'POST',
-            body: readStream,
-            contentLength: encResult.fileSize,
-            contentType: content.mimetype
-        });
-        const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
-        const parsed = parseUploadResponse(responseBody, uploadResponse.status);
-        return {
-            ...parsed,
-            mediaKey,
-            fileSha256: encResult.fileSha256,
-            fileEncSha256: encResult.fileEncSha256,
-            fileLength: encResult.plaintextLength
-        };
-    }
-    finally {
-        if (readStream && !readStream.closed) {
-            await new Promise((resolve) => {
-                readStream.once('close', resolve);
-                readStream.destroy();
-            });
-        }
-        await WaMediaCrypto.cleanupEncryptedFile(encResult.filePath);
-    }
-}

package/dist/esm/media/WaMediaCrypto.js

@@ -1,304 +0,0 @@
-import { createCipheriv, createDecipheriv, createHash, createHmac } from 'node:crypto';
-import { once } from 'node:events';
-import { createWriteStream } from 'node:fs';
-import { stat, unlink } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { PassThrough } from 'node:stream';
-import { hkdf } from '../crypto/core/hkdf.js';
-import { aesCbcDecrypt, aesCbcEncrypt, hmacSign, importAesCbcKey, importHmacKey, sha256 } from '../crypto/core/primitives.js';
-import { randomBytesAsync } from '../crypto/core/random.js';
-import { ENC_KEY_END, ENC_KEY_START, HMAC_TRUNCATED_SIZE, IV_SIZE, MAC_KEY_END, MAC_KEY_START, MEDIA_HKDF_SIZE } from './constants.js';
-import { WA_APP_STATE_KEY_TYPES, getWaMediaHkdfInfo } from '../protocol/constants.js';
-import { assertByteLength, concatBytes, EMPTY_BYTES, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
-import { toError } from '../util/primitives.js';
-export class WaMediaCrypto {
-    static async generateMediaKey() {
-        return randomBytesAsync(32);
-    }
-    static async deriveKeys(mediaType, mediaKey) {
-        assertByteLength(mediaKey, 32, `invalid media key length ${mediaKey.byteLength}, expected 32`);
-        const info = mediaTypeToHkdfInfo(mediaType);
-        const expanded = await hkdf(mediaKey, null, info, MEDIA_HKDF_SIZE);
-        return {
-            iv: expanded.subarray(0, IV_SIZE),
-            encKey: expanded.subarray(ENC_KEY_START, ENC_KEY_END),
-            macKey: expanded.subarray(MAC_KEY_START, MAC_KEY_END),
-            refKey: expanded.subarray(MAC_KEY_END, MEDIA_HKDF_SIZE)
-        };
-    }
-    static async encryptBytes(mediaType, mediaKey, plaintext) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const [aesKey, macKey] = await Promise.all([
-            importAesCbcKey(keys.encKey),
-            importHmacKey(keys.macKey)
-        ]);
-        const ciphertext = await aesCbcEncrypt(aesKey, keys.iv, plaintext);
-        const ivCiphertext = concatBytes([keys.iv, ciphertext]);
-        const mac = await hmacSign(macKey, ivCiphertext);
-        const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
-        const ciphertextHmac = concatBytes([ciphertext, signature]);
-        const [fileSha256, fileEncSha256] = await Promise.all([
-            sha256(plaintext),
-            sha256(ciphertextHmac)
-        ]);
-        return { ciphertextHmac, fileSha256, fileEncSha256 };
-    }
-    static async decryptBytes(mediaType, mediaKey, ciphertextHmac, expectedFileSha256, expectedFileEncSha256) {
-        if (ciphertextHmac.byteLength < HMAC_TRUNCATED_SIZE) {
-            throw new Error(`ciphertext too short: ${ciphertextHmac.byteLength}`);
-        }
-        if (expectedFileEncSha256) {
-            const computedEncHash = await sha256(ciphertextHmac);
-            if (!uint8Equal(computedEncHash, expectedFileEncSha256)) {
-                throw new Error('encrypted file hash mismatch');
-            }
-        }
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const ciphertext = ciphertextHmac.subarray(0, ciphertextHmac.byteLength - HMAC_TRUNCATED_SIZE);
-        const expectedMac = ciphertextHmac.subarray(ciphertextHmac.byteLength - HMAC_TRUNCATED_SIZE);
-        const ivCiphertext = concatBytes([keys.iv, ciphertext]);
-        const [macKey, aesKey] = await Promise.all([
-            importHmacKey(keys.macKey),
-            importAesCbcKey(keys.encKey)
-        ]);
-        const mac = await hmacSign(macKey, ivCiphertext);
-        const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
-        if (!uint8TimingSafeEqual(signature, expectedMac)) {
-            throw new Error('media MAC mismatch');
-        }
-        const plaintext = await aesCbcDecrypt(aesKey, keys.iv, ciphertext);
-        const fileSha256 = await sha256(plaintext);
-        if (expectedFileSha256 && !uint8Equal(fileSha256, expectedFileSha256)) {
-            throw new Error('plaintext file hash mismatch');
-        }
-        const fileEncSha256 = expectedFileEncSha256 ?? (await sha256(ciphertextHmac));
-        return { plaintext, fileSha256, fileEncSha256 };
-    }
-    static async encryptReadable(mediaType, mediaKey, plaintext) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const encrypted = new PassThrough();
-        const metadata = pumpEncryption(plaintext, encrypted, keys);
-        return { encrypted, metadata };
-    }
-    static async encryptToFile(mediaType, mediaKey, plaintext) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const filePath = join(tmpdir(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        const output = createWriteStream(filePath);
-        try {
-            const metadata = await pumpEncryptionToWritable(plaintext, output, keys);
-            const fileSize = (await stat(filePath)).size;
-            return { filePath, fileSize, ...metadata };
-        }
-        catch (error) {
-            await unlink(filePath).catch(() => undefined);
-            throw error;
-        }
-    }
-    static async cleanupEncryptedFile(filePath) {
-        await unlink(filePath).catch(() => undefined);
-    }
-    static async decryptReadable(encrypted, options) {
-        const keys = await WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
-        const plaintext = new PassThrough();
-        const metadata = pumpDecryption(encrypted, plaintext, keys, options);
-        return { plaintext, metadata };
-    }
-    static encryptedLength(plaintextLength) {
-        if (!Number.isFinite(plaintextLength) || plaintextLength < 0) {
-            throw new Error(`invalid plaintext length ${plaintextLength}`);
-        }
-        const paddedLength = Math.ceil((plaintextLength + 1) / 16) * 16;
-        return paddedLength + HMAC_TRUNCATED_SIZE;
-    }
-}
-async function pumpEncryption(plaintext, encrypted, keys) {
-    const plainHash = createHash('sha256');
-    const encHash = createHash('sha256');
-    const hmac = createHmac('sha256', keys.macKey);
-    const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
-    let plaintextLength = 0;
-    hmac.update(keys.iv);
-    try {
-        for await (const chunk of plaintext) {
-            const plainChunk = toChunkBytes(chunk);
-            if (plainChunk.byteLength === 0) {
-                continue;
-            }
-            plaintextLength += plainChunk.byteLength;
-            plainHash.update(plainChunk);
-            const encryptedChunk = cipher.update(plainChunk);
-            if (encryptedChunk.byteLength > 0) {
-                hmac.update(encryptedChunk);
-                encHash.update(encryptedChunk);
-                await writeChunk(encrypted, encryptedChunk);
-            }
-        }
-        const encryptedFinal = cipher.final();
-        if (encryptedFinal.byteLength > 0) {
-            hmac.update(encryptedFinal);
-            encHash.update(encryptedFinal);
-            await writeChunk(encrypted, encryptedFinal);
-        }
-        const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
-        encHash.update(signature);
-        await writeChunk(encrypted, signature);
-        encrypted.end();
-        return {
-            fileSha256: toBytesView(plainHash.digest()),
-            fileEncSha256: toBytesView(encHash.digest()),
-            plaintextLength
-        };
-    }
-    catch (error) {
-        const normalized = toError(error);
-        encrypted.destroy(normalized);
-        throw normalized;
-    }
-}
-async function writeChunkToWritable(stream, chunk) {
-    if (chunk.byteLength === 0) {
-        return;
-    }
-    if (stream.write(chunk)) {
-        return;
-    }
-    await new Promise((resolve, reject) => {
-        const onDrain = () => {
-            stream.off('error', onError);
-            resolve();
-        };
-        const onError = (err) => {
-            stream.off('drain', onDrain);
-            reject(err);
-        };
-        stream.once('drain', onDrain);
-        stream.once('error', onError);
-    });
-}
-async function endWritable(stream) {
-    return new Promise((resolve, reject) => {
-        stream.on('error', reject);
-        stream.end(() => resolve());
-    });
-}
-async function pumpEncryptionToWritable(plaintext, output, keys) {
-    const plainHash = createHash('sha256');
-    const encHash = createHash('sha256');
-    const hmac = createHmac('sha256', keys.macKey);
-    const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
-    let plaintextLength = 0;
-    hmac.update(keys.iv);
-    try {
-        for await (const chunk of plaintext) {
-            const plainChunk = toChunkBytes(chunk);
-            if (plainChunk.byteLength === 0) {
-                continue;
-            }
-            plaintextLength += plainChunk.byteLength;
-            plainHash.update(plainChunk);
-            const encryptedChunk = cipher.update(plainChunk);
-            if (encryptedChunk.byteLength > 0) {
-                hmac.update(encryptedChunk);
-                encHash.update(encryptedChunk);
-                await writeChunkToWritable(output, encryptedChunk);
-            }
-        }
-        const encryptedFinal = cipher.final();
-        if (encryptedFinal.byteLength > 0) {
-            hmac.update(encryptedFinal);
-            encHash.update(encryptedFinal);
-            await writeChunkToWritable(output, encryptedFinal);
-        }
-        const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
-        encHash.update(signature);
-        await writeChunkToWritable(output, signature);
-        await endWritable(output);
-        return {
-            fileSha256: toBytesView(plainHash.digest()),
-            fileEncSha256: toBytesView(encHash.digest()),
-            plaintextLength
-        };
-    }
-    catch (error) {
-        const normalized = toError(error);
-        output.destroy(normalized);
-        throw normalized;
-    }
-}
-async function pumpDecryption(encrypted, plaintext, keys, options) {
-    const plainHash = createHash('sha256');
-    const encHash = createHash('sha256');
-    const hmac = createHmac('sha256', keys.macKey);
-    const decipher = createDecipheriv('aes-256-cbc', keys.encKey, keys.iv);
-    hmac.update(keys.iv);
-    try {
-        let trailing = EMPTY_BYTES;
-        for await (const chunk of encrypted) {
-            const bytes = toChunkBytes(chunk);
-            if (bytes.byteLength === 0) {
-                continue;
-            }
-            encHash.update(bytes);
-            const merged = trailing.byteLength === 0 ? bytes : concatBytes([trailing, bytes]);
-            if (merged.byteLength <= HMAC_TRUNCATED_SIZE) {
-                trailing = merged;
-                continue;
-            }
-            const ciphertextChunk = merged.subarray(0, merged.byteLength - HMAC_TRUNCATED_SIZE);
-            trailing = merged.subarray(merged.byteLength - HMAC_TRUNCATED_SIZE);
-            hmac.update(ciphertextChunk);
-            const plainChunk = decipher.update(ciphertextChunk);
-            if (plainChunk.byteLength > 0) {
-                plainHash.update(plainChunk);
-                await writeChunk(plaintext, plainChunk);
-            }
-        }
-        if (trailing.byteLength !== HMAC_TRUNCATED_SIZE) {
-            throw new Error(`ciphertext too short: ${trailing.byteLength}`);
-        }
-        const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
-        if (!uint8TimingSafeEqual(signature, trailing)) {
-            throw new Error('media MAC mismatch');
-        }
-        const plainFinal = decipher.final();
-        if (plainFinal.byteLength > 0) {
-            plainHash.update(plainFinal);
-            await writeChunk(plaintext, plainFinal);
-        }
-        const fileSha256 = toBytesView(plainHash.digest());
-        const fileEncSha256 = toBytesView(encHash.digest());
-        if (options.expectedFileEncSha256 &&
-            !uint8Equal(fileEncSha256, options.expectedFileEncSha256)) {
-            throw new Error('encrypted file hash mismatch');
-        }
-        if (options.expectedFileSha256 && !uint8Equal(fileSha256, options.expectedFileSha256)) {
-            throw new Error('plaintext file hash mismatch');
-        }
-        plaintext.end();
-        return { fileSha256, fileEncSha256 };
-    }
-    catch (error) {
-        const normalized = toError(error);
-        plaintext.destroy(normalized);
-        throw normalized;
-    }
-}
-function mediaTypeToHkdfInfo(mediaType) {
-    if (mediaType === 'ptv') {
-        return getWaMediaHkdfInfo('video');
-    }
-    if (mediaType === 'history') {
-        return getWaMediaHkdfInfo(WA_APP_STATE_KEY_TYPES.MD_MSG_HIST);
-    }
-    return getWaMediaHkdfInfo(mediaType);
-}
-async function writeChunk(stream, chunk) {
-    if (chunk.byteLength === 0) {
-        return;
-    }
-    if (stream.write(chunk)) {
-        return;
-    }
-    await once(stream, 'drain');
-}

package/dist/esm/message/addon-crypto.js

@@ -1,59 +0,0 @@
-import { aesGcmDecrypt, aesGcmEncrypt, importAesGcmKey } from '../crypto/index.js';
-import { assertMessageSecret, createUseCaseSecret, WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret.js';
-import { EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../util/bytes.js';
-const WA_ADDON_ENCRYPTION_NONCE_BYTES = 12;
-export function shouldUseAddonAdditionalData(modificationType) {
-    return (modificationType === WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE ||
-        modificationType === WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE);
-}
-export function buildAddonAdditionalData(stanzaId, addOnSenderJid) {
-    if (!stanzaId.trim()) {
-        throw new Error('stanza id must be a non-empty string');
-    }
-    if (!addOnSenderJid.trim()) {
-        throw new Error('addon sender jid must be a non-empty string');
-    }
-    return TEXT_ENCODER.encode(`${stanzaId}\u0000${addOnSenderJid}`);
-}
-export async function encryptAddonPayload(input) {
-    const secret = await createUseCaseSecret({
-        messageSecret: assertMessageSecret(input.messageSecret),
-        stanzaId: input.stanzaId,
-        parentMsgOriginalSender: input.parentMsgOriginalSender,
-        modificationSender: input.modificationSender,
-        modificationType: input.modificationType
-    });
-    const key = await importAesGcmKey(secret, ['encrypt']);
-    const iv = assertAddonIv(input.iv);
-    const additionalData = resolveAddonAdditionalData(input);
-    return aesGcmEncrypt(key, iv, toBytesView(input.payload), additionalData);
-}
-export async function decryptAddonPayload(input) {
-    const secret = await createUseCaseSecret({
-        messageSecret: assertMessageSecret(input.messageSecret),
-        stanzaId: input.stanzaId,
-        parentMsgOriginalSender: input.parentMsgOriginalSender,
-        modificationSender: input.modificationSender,
-        modificationType: input.modificationType
-    });
-    const key = await importAesGcmKey(secret, ['decrypt']);
-    const iv = assertAddonIv(input.iv);
-    const additionalData = resolveAddonAdditionalData(input);
-    return aesGcmDecrypt(key, iv, toBytesView(input.ciphertext), additionalData);
-}
-function assertAddonIv(iv) {
-    const normalized = toBytesView(iv);
-    if (normalized.byteLength !== WA_ADDON_ENCRYPTION_NONCE_BYTES) {
-        throw new Error(`addon iv must be ${WA_ADDON_ENCRYPTION_NONCE_BYTES} bytes (got ${normalized.byteLength})`);
-    }
-    return normalized;
-}
-function resolveAddonAdditionalData(input) {
-    if (input.additionalData) {
-        return toBytesView(input.additionalData);
-    }
-    if (!shouldUseAddonAdditionalData(input.modificationType)) {
-        return EMPTY_BYTES;
-    }
-    return buildAddonAdditionalData(input.stanzaId, input.modificationSender);
-}