zapo-js 0.2.0 → 0.3.0

package/dist/esm/client/media.js

@@ -0,0 +1,234 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { open, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { toBytesView } from '../util/bytes.js';
+import { toError } from '../util/primitives.js';
+export async function readFileHead(filePath, bytes) {
+    const fh = await open(filePath, 'r');
+    try {
+        const buf = new Uint8Array(bytes);
+        const { bytesRead } = await fh.read(buf, 0, bytes, 0);
+        return buf.subarray(0, bytesRead);
+    }
+    finally {
+        await fh.close();
+    }
+}
+const RIFF_HEADER_SIZE = 12;
+const CHUNK_HEADER_SIZE = 8;
+const CHUNK_ID_SIZE = 4;
+const ANMF_ID = [0x41, 0x4e, 0x4d, 0x46];
+export function parseWebpAnimation(data) {
+    if (data.byteLength < RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE)
+        return null;
+    let offset = RIFF_HEADER_SIZE;
+    if (data[offset] !== 0x56 ||
+        data[offset + 1] !== 0x50 ||
+        data[offset + 2] !== 0x38 ||
+        data[offset + 3] !== 0x58) {
+        return null;
+    }
+    // Skip VP8X chunk: 8 byte header + 10 byte payload
+    offset += CHUNK_HEADER_SIZE + 10;
+    while (offset + CHUNK_HEADER_SIZE <= data.byteLength) {
+        const isAnmf = data[offset] === ANMF_ID[0] &&
+            data[offset + 1] === ANMF_ID[1] &&
+            data[offset + 2] === ANMF_ID[2] &&
+            data[offset + 3] === ANMF_ID[3];
+        const sizeOffset = offset + CHUNK_ID_SIZE;
+        if (sizeOffset + 4 > data.byteLength)
+            return null;
+        let chunkSize = (data[sizeOffset] |
+            (data[sizeOffset + 1] << 8) |
+            (data[sizeOffset + 2] << 16) |
+            (data[sizeOffset + 3] << 24)) >>>
+            0;
+        if (chunkSize % 2 !== 0)
+            chunkSize += 1;
+        const nextOffset = offset + CHUNK_HEADER_SIZE + chunkSize;
+        if (nextOffset <= offset || nextOffset > data.byteLength)
+            return null;
+        if (isAnmf) {
+            return { isAnimated: true, firstFrameLength: nextOffset };
+        }
+        offset = nextOffset;
+    }
+    return null;
+}
+const IMAGE_THUMB_MAX_EDGE = 320;
+const VIDEO_THUMB_MAX_EDGE = 48;
+const STICKER_THUMB_MAX_EDGE = 100;
+const EMPTY_PROCESSED = {};
+export function isReadableStream(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'pipe' in value &&
+        typeof value.pipe === 'function');
+}
+async function streamToTempFile(source) {
+    const filePath = join(tmpdir(), `zapo-media-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    try {
+        await pipeline(source, createWriteStream(filePath));
+    }
+    catch (error) {
+        await unlink(filePath).catch(() => undefined);
+        throw error;
+    }
+    return filePath;
+}
+export async function cleanupTempFile(filePath) {
+    await unlink(filePath).catch(() => undefined);
+}
+export async function resolveMediaInputs(shouldProcess, raw) {
+    if (typeof raw === 'string') {
+        return {
+            processorInput: raw,
+            uploadMedia: createReadStream(raw)
+        };
+    }
+    if (isReadableStream(raw)) {
+        if (shouldProcess) {
+            const tempFilePath = await streamToTempFile(raw);
+            return {
+                processorInput: tempFilePath,
+                uploadMedia: createReadStream(tempFilePath),
+                tempFilePath
+            };
+        }
+        return { uploadMedia: raw };
+    }
+    const bytes = toBytesView(raw);
+    return { processorInput: bytes, uploadMedia: bytes };
+}
+function shouldGenerateThumbnail(media, content) {
+    if (!media?.processor || media.generateThumbnail === false) {
+        return false;
+    }
+    switch (content.type) {
+        case 'image':
+            return content.jpegThumbnail === undefined && !!media.processor.generateImageThumbnail;
+        case 'video':
+        case 'ptv':
+            return content.jpegThumbnail === undefined && !!media.processor.generateVideoThumbnail;
+        case 'document':
+            return !!media.processor.generateImageThumbnail;
+        default:
+            return false;
+    }
+}
+function shouldProbeMedia(media, content) {
+    if (!media?.processor?.probeMedia || media.generateProbe === false) {
+        return false;
+    }
+    switch (content.type) {
+        case 'video':
+        case 'ptv':
+            return (content.seconds === undefined ||
+                content.width === undefined ||
+                content.height === undefined);
+        case 'audio':
+            return content.seconds === undefined;
+        default:
+            return false;
+    }
+}
+function shouldGenerateWaveform(media, content) {
+    return (!!media?.processor?.computeWaveform &&
+        media.generateWaveform !== false &&
+        content.type === 'audio' &&
+        content.waveform === undefined);
+}
+function shouldGenerateStickerThumbnail(media, content) {
+    return (!!media?.processor?.generateStickerThumbnail &&
+        media.generateStickerThumbnail !== false &&
+        content.type === 'sticker' &&
+        content.pngThumbnail === undefined);
+}
+export function hasMediaProcessingTasks(media, content) {
+    return (shouldGenerateThumbnail(media, content) ||
+        shouldProbeMedia(media, content) ||
+        shouldGenerateWaveform(media, content) ||
+        shouldGenerateStickerThumbnail(media, content));
+}
+async function runProcessorStep(step, content, logger, fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        logger.error('media processor step failed, skipping step', {
+            type: content.type,
+            step,
+            message: toError(error).message
+        });
+        return null;
+    }
+}
+export async function runMediaProcessor(media, input, content, logger) {
+    const processor = media?.processor;
+    if (!processor || !hasMediaProcessingTasks(media, content) || !input)
+        return EMPTY_PROCESSED;
+    const result = {};
+    const isVideo = content.type === 'video' || content.type === 'ptv';
+    const thumbFn = isVideo ? processor.generateVideoThumbnail : processor.generateImageThumbnail;
+    const thumbMaxEdge = isVideo ? VIDEO_THUMB_MAX_EDGE : IMAGE_THUMB_MAX_EDGE;
+    const thumbTask = shouldGenerateThumbnail(media, content)
+        ? runProcessorStep('thumbnail', content, logger, () => thumbFn(input, thumbMaxEdge))
+        : null;
+    const probeTask = shouldProbeMedia(media, content)
+        ? runProcessorStep('probe', content, logger, () => processor.probeMedia(input))
+        : null;
+    const [thumb, probe] = await Promise.all([thumbTask, probeTask]);
+    if (thumb) {
+        result.jpegThumbnail = thumb.jpegThumbnail;
+        if (!isVideo && !probe) {
+            result.width = thumb.width;
+            result.height = thumb.height;
+        }
+    }
+    if (probe) {
+        if (probe.durationSeconds !== undefined &&
+            !('seconds' in content && content.seconds !== undefined)) {
+            result.seconds = Math.floor(probe.durationSeconds);
+        }
+        if (!('width' in content && content.width !== undefined) && probe.width !== undefined) {
+            result.width = probe.width;
+        }
+        if (!('height' in content && content.height !== undefined) && probe.height !== undefined) {
+            result.height = probe.height;
+        }
+    }
+    if (shouldGenerateWaveform(media, content)) {
+        const waveformResult = await runProcessorStep('waveform', content, logger, () => processor.computeWaveform(input));
+        if (waveformResult) {
+            result.waveform = waveformResult.waveform;
+            if (result.seconds === undefined &&
+                !('seconds' in content && content.seconds !== undefined)) {
+                result.seconds = Math.floor(waveformResult.durationSeconds);
+            }
+        }
+    }
+    if (content.type === 'sticker') {
+        if (shouldGenerateStickerThumbnail(media, content)) {
+            const stickerThumb = await runProcessorStep('stickerThumbnail', content, logger, () => processor.generateStickerThumbnail(input, STICKER_THUMB_MAX_EDGE));
+            if (stickerThumb) {
+                result.pngThumbnail = stickerThumb.pngThumbnail;
+                result.width = stickerThumb.width;
+                result.height = stickerThumb.height;
+            }
+        }
+        if (content.isAnimated === undefined) {
+            const header = typeof input === 'string' ? await readFileHead(input, 100) : input;
+            const anim = parseWebpAnimation(header);
+            if (anim) {
+                result.isAnimated = true;
+                result.firstFrameLength = anim.firstFrameLength;
+            }
+            else {
+                result.isAnimated = false;
+            }
+        }
+    }
+    return result;
+}

package/dist/esm/client/messages.js

@@ -1,11 +1,12 @@
 import { createReadStream } from 'node:fs';
+import { cleanupTempFile, hasMediaProcessingTasks, isReadableStream, parseWebpAnimation, readFileHead, resolveMediaInputs, runMediaProcessor } from './media.js';
 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 { bytesToBase64UrlSafe, TEXT_DECODER } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 export async function buildMediaMessageContent(options, content) {
     if (typeof content === 'string') {
@@ -31,6 +32,9 @@ export async function getMediaConn(options, forceRefresh = false) {
     options.setMediaConnCache(mediaConn);
     return mediaConn;
 }
+function needsSidecar(content) {
+    return content.type === 'video' || content.type === 'ptv' || content.type === 'audio';
+}
 function resolveUploadType(content) {
     if (content.type === 'video' && content.gifPlayback)
         return 'gif';
@@ -38,85 +42,146 @@ function resolveUploadType(content) {
         return 'ptt';
     return content.type;
 }
-function isReadableStream(value) {
-    return (!!value &&
-        typeof value === 'object' &&
-        'pipe' in value &&
-        typeof value.pipe === 'function');
+function resolveMimetype(content) {
+    if (content.mimetype)
+        return content.mimetype;
+    if (content.type === 'sticker')
+        return 'image/webp';
+    throw new Error(`mimetype is required for ${content.type} messages`);
 }
 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
+    const needsTempFile = hasMediaProcessingTasks(options.media, content) ||
+        (content.type === 'sticker' && content.firstFrameLength === undefined);
+    const resolved = await resolveMediaInputs(needsTempFile, content.media);
+    try {
+        let detectedFirstFrameLength;
+        if (content.type === 'sticker' &&
+            content.firstFrameLength === undefined &&
+            resolved.processorInput) {
+            const input = resolved.processorInput;
+            const header = typeof input === 'string' ? await readFileHead(input, 100) : input.subarray(0, 100);
+            detectedFirstFrameLength = parseWebpAnimation(header)?.firstFrameLength;
+        }
+        const firstFrameLength = content.type === 'sticker'
+            ? (content.firstFrameLength ?? detectedFirstFrameLength)
+            : undefined;
+        const uploadPromise = isReadableStream(resolved.uploadMedia)
+            ? uploadMediaStream(options, content, resolved.uploadMedia, firstFrameLength)
+            : uploadMediaBytes(options, content, resolved.uploadMedia, firstFrameLength);
+        const processPromise = runMediaProcessor(options.media, resolved.processorInput, content, options.logger);
+        const [uploadResult, processResult] = await Promise.allSettled([
+            uploadPromise,
+            processPromise
+        ]);
+        if (uploadResult.status === 'rejected')
+            throw uploadResult.reason;
+        if (processResult.status === 'rejected')
+            throw processResult.reason;
+        const uploaded = uploadResult.value;
+        const processed = processResult.value;
+        const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
+        const uploadedFields = {
+            url: uploaded.url,
+            fileSha256: uploaded.fileSha256,
+            fileLength: uploaded.fileLength,
+            mediaKey: uploaded.mediaKey,
+            fileEncSha256: uploaded.fileEncSha256,
+            directPath: uploaded.directPath,
+            mediaKeyTimestamp,
+            mimetype: resolveMimetype(content)
+        };
+        function spread(c) {
+            const result = {};
+            for (const key in c) {
+                if (key !== 'type' &&
+                    key !== 'media' &&
+                    key !== 'fileLength' &&
+                    key !== 'mimetype') {
+                    result[key] = c[key];
                 }
-            };
-        default:
-            throw new Error(`unsupported media message type: ${String(content.type)}`);
+            }
+            return result;
+        }
+        switch (content.type) {
+            case 'image':
+                return {
+                    imageMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                    }
+                };
+            case 'video':
+                return {
+                    videoMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                        streamingSidecar: uploaded.streamingSidecar,
+                        metadataUrl: uploaded.metadataUrl
+                    }
+                };
+            case 'ptv':
+                return {
+                    ptvMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                        streamingSidecar: uploaded.streamingSidecar
+                    }
+                };
+            case 'audio':
+                return {
+                    audioMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        streamingSidecar: uploaded.streamingSidecar,
+                        waveform: content.waveform ?? processed.waveform
+                    }
+                };
+            case 'document':
+                return {
+                    documentMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        fileName: content.fileName ?? 'file',
+                        title: content.title ?? content.fileName ?? undefined,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                    }
+                };
+            case 'sticker':
+                return {
+                    stickerMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        pngThumbnail: content.pngThumbnail ?? processed.pngThumbnail,
+                        isAnimated: content.isAnimated ??
+                            processed.isAnimated ??
+                            firstFrameLength !== undefined,
+                        firstFrameLength: content.firstFrameLength ?? uploaded.firstFrameLength,
+                        firstFrameSidecar: content.firstFrameSidecar ?? uploaded.firstFrameSidecar,
+                        stickerSentTs: content.stickerSentTs ?? Date.now()
+                    }
+                };
+            default:
+                throw new Error(`unsupported media message type: ${String(content.type)}`);
+        }
+    }
+    finally {
+        if (resolved.tempFilePath) {
+            await cleanupTempFile(resolved.tempFilePath);
+        }
     }
 }
 function buildUploadUrl(host, uploadType, auth, fileEncSha256) {
@@ -147,11 +212,14 @@ function parseUploadResponse(body, status) {
         ...(parsed.metadata_url ? { metadataUrl: parsed.metadata_url } : {})
     };
 }
-async function uploadMediaBytes(options, content, mediaBytes) {
+async function uploadMediaBytes(options, content, mediaBytes, firstFrameLength) {
     const uploadType = resolveUploadType(content);
     const mediaKey = await WaMediaCrypto.generateMediaKey();
     const [encrypted, mediaConn] = await Promise.all([
-        WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes),
+        WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes, {
+            sidecar: needsSidecar(content),
+            firstFrameLength
+        }),
         getMediaConn(options)
     ]);
     const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
@@ -166,7 +234,7 @@ async function uploadMediaBytes(options, content, mediaBytes) {
         method: 'POST',
         body: encrypted.ciphertextHmac,
         contentLength: encrypted.ciphertextHmac.byteLength,
-        contentType: content.mimetype
+        contentType: resolveMimetype(content)
     });
     const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
     const parsed = parseUploadResponse(responseBody, uploadResponse.status);
@@ -175,13 +243,19 @@ async function uploadMediaBytes(options, content, mediaBytes) {
         mediaKey,
         fileSha256: encrypted.fileSha256,
         fileEncSha256: encrypted.fileEncSha256,
-        fileLength: mediaBytes.byteLength
+        fileLength: mediaBytes.byteLength,
+        streamingSidecar: encrypted.streamingSidecar,
+        firstFrameSidecar: encrypted.firstFrameSidecar,
+        firstFrameLength
     };
 }
-async function uploadMediaStream(options, content, stream) {
+async function uploadMediaStream(options, content, stream, firstFrameLength) {
     const uploadType = resolveUploadType(content);
     const mediaKey = await WaMediaCrypto.generateMediaKey();
-    const encResult = await WaMediaCrypto.encryptToFile(uploadType, mediaKey, stream);
+    const encResult = await WaMediaCrypto.encryptToFile(uploadType, mediaKey, stream, {
+        sidecar: needsSidecar(content),
+        firstFrameLength
+    });
     let readStream;
     try {
         const mediaConn = await getMediaConn(options);
@@ -200,7 +274,7 @@ async function uploadMediaStream(options, content, stream) {
             method: 'POST',
             body: readStream,
             contentLength: encResult.fileSize,
-            contentType: content.mimetype
+            contentType: resolveMimetype(content)
         });
         const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
         const parsed = parseUploadResponse(responseBody, uploadResponse.status);
@@ -209,7 +283,10 @@ async function uploadMediaStream(options, content, stream) {
             mediaKey,
             fileSha256: encResult.fileSha256,
             fileEncSha256: encResult.fileEncSha256,
-            fileLength: encResult.plaintextLength
+            fileLength: encResult.plaintextLength,
+            streamingSidecar: encResult.streamingSidecar,
+            firstFrameSidecar: encResult.firstFrameSidecar,
+            firstFrameLength
         };
     }
     finally {

package/dist/esm/crypto/core/index.js

@@ -8,3 +8,4 @@ export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent }
 export { buildNonce } from '../core/nonce.js';
 export { randomBytesAsync, randomFillAsync, randomIntAsync } from '../core/random.js';
 export { sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt } from '../core/primitives.js';
+export { xeddsaSign, xeddsaVerify } from '../core/xeddsa.js';

package/dist/esm/crypto/core/random.js

@@ -1,11 +1,5 @@
 import { randomBytes, randomFill, randomInt } from 'node:crypto';
 import { promisify } from 'node:util';
-import { toBytesView } from '../../util/bytes.js';
-const randomBytesAsyncImpl = promisify(randomBytes);
-const randomIntAsyncImpl = promisify(randomInt);
-export async function randomBytesAsync(size) {
-    return toBytesView(await randomBytesAsyncImpl(size));
-}
 export async function randomFillAsync(target, offset, size) {
     await new Promise((resolve, reject) => {
         const onDone = (error) => {
@@ -27,4 +21,5 @@ export async function randomFillAsync(target, offset, size) {
     });
     return target;
 }
-export const randomIntAsync = randomIntAsyncImpl;
+export const randomIntAsync = promisify(randomInt);
+export const randomBytesAsync = promisify(randomBytes);

package/dist/esm/crypto/core/xeddsa.js

@@ -0,0 +1,53 @@
+import { sha512 } from '../core/primitives.js';
+import { randomBytesAsync } from '../core/random.js';
+import { Ed25519 } from '../curves/Ed25519.js';
+import { clampCurvePrivateKeyInPlace, montgomeryToEdwardsPublic } from '../curves/X25519.js';
+import { encodeExtendedPoint, scalarMultBase } from '../math/edwards.js';
+import { bigIntToBytesLE, bytesToBigIntLE } from '../math/le.js';
+import { modGroup } from '../math/mod.js';
+import { assertByteLength, concatBytes } from '../../util/bytes.js';
+const PREFIX_SIGNATURE_RANDOM = new Uint8Array([
+    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+]);
+export async function xeddsaVerify(curvePublicKey, message, signature) {
+    if (signature.length !== 64) {
+        return false;
+    }
+    if ((signature[63] & 0x60) !== 0) {
+        return false;
+    }
+    const lastByteIndex = 63;
+    const originalLastByte = signature[lastByteIndex];
+    const signBit = originalLastByte & 0x80;
+    signature[lastByteIndex] = originalLastByte & 0x7f;
+    const edPublic = montgomeryToEdwardsPublic(curvePublicKey, signBit);
+    try {
+        return await Ed25519.verify(message, signature, edPublic);
+    }
+    finally {
+        signature[lastByteIndex] = originalLastByte;
+    }
+}
+export async function xeddsaSign(privateKey, message) {
+    assertByteLength(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
+    const clampedPrivateKey = clampCurvePrivateKeyInPlace(privateKey);
+    const privateScalar = bytesToBigIntLE(clampedPrivateKey);
+    const encodedPublic = encodeExtendedPoint(scalarMultBase(privateScalar));
+    const pubKeySignBit = encodedPublic[31] & 0x80;
+    const randomSuffix = await randomBytesAsync(64);
+    const hashInput = concatBytes([
+        PREFIX_SIGNATURE_RANDOM,
+        clampedPrivateKey,
+        message,
+        randomSuffix
+    ]);
+    const r = modGroup(bytesToBigIntLE(await sha512(hashInput)));
+    const encodedR = encodeExtendedPoint(scalarMultBase(r));
+    const hInput = concatBytes([encodedR, encodedPublic, message]);
+    const h = modGroup(bytesToBigIntLE(await sha512(hInput)));
+    const s = modGroup(r + h * privateScalar);
+    const encodedS = bigIntToBytesLE(s, 32);
+    encodedS[31] = (encodedS[31] & 0x7f) | pubKeySignBit;
+    return concatBytes([encodedR, encodedS]);
+}

package/dist/esm/crypto/curves/X25519.js

@@ -1,9 +1,11 @@
-import { webcrypto } from 'node:crypto';
-import { X25519_PKCS8_PREFIX } from '../curves/constants.js';
+import { createPrivateKey, createPublicKey, diffieHellman, webcrypto } from 'node:crypto';
+import { X25519_PKCS8_PREFIX, X25519_SPKI_PREFIX } from '../curves/constants.js';
 import { pkcs8FromRawPrivate } from '../curves/types.js';
 import { FE_ONE } from '../math/constants.js';
 import { fe, feAdd, feFromBytes, feInv, feMul, fePack, feSub } from '../math/fe.js';
 import { assertByteLength, decodeBase64Url, toBytesView } from '../../util/bytes.js';
+import { isBunRuntime } from '../../util/runtime.js';
+const IS_BUN = isBunRuntime();
 // Pre-allocated temps for montgomeryToEdwardsPublic (safe: single-threaded)
 const _mx = fe();
 const _m1 = fe();
@@ -64,6 +66,22 @@ export class X25519 {
     static async scalarMult(privKey, pubKey) {
         assertByteLength(privKey, 32, 'x25519 private key must be 32 bytes');
         assertByteLength(pubKey, 32, 'x25519 public key must be 32 bytes');
+        // TODO: When Bun supports deriveBits with X25519 change to Async Web Crypto API
+        // https://github.com/oven-sh/bun/pull/29152
+        if (IS_BUN) {
+            const spki = new Uint8Array(X25519_SPKI_PREFIX.length + 32);
+            spki.set(X25519_SPKI_PREFIX, 0);
+            spki.set(pubKey, X25519_SPKI_PREFIX.length);
+            const shared = diffieHellman({
+                privateKey: createPrivateKey({
+                    key: pkcs8FromRawPrivate(X25519_PKCS8_PREFIX, privKey),
+                    format: 'der',
+                    type: 'pkcs8'
+                }),
+                publicKey: createPublicKey({ key: spki, format: 'der', type: 'spki' })
+            });
+            return toBytesView(shared);
+        }
         const [privateKey, publicKey] = await Promise.all([
             webcrypto.subtle.importKey('pkcs8', pkcs8FromRawPrivate(X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, false, ['deriveBits']),
             webcrypto.subtle.importKey('raw', pubKey, { name: 'X25519' }, false, [])

package/dist/esm/crypto/curves/constants.js

@@ -1,3 +1,4 @@
 import { hexToBytes } from '../../util/bytes.js';
 export const X25519_PKCS8_PREFIX = hexToBytes('302e020100300506032b656e04220420');
+export const X25519_SPKI_PREFIX = hexToBytes('302a300506032b656e032100');
 export const ED25519_PKCS8_PREFIX = hexToBytes('302e020100300506032b657004220420');