zapo-js 0.1.2 → 0.2.0

package/dist/esm/client/messaging/fanout.js

@@ -1,21 +1,20 @@
-import { normalizeDeviceJid, splitJid, toUserJid } from '../../protocol/jid.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { isHostedDeviceJid, normalizeDeviceJid, splitJid, toUserJid } from '../../protocol/jid.js';
 import { toError } from '../../util/primitives.js';
 export function createDeviceFanoutResolver(options) {
     const { signalDeviceSync, getCurrentMeJid, getCurrentMeLid, logger } = options;
-    const requireCurrentMeJid = (context) => {
-        const meJid = getCurrentMeJid();
-        if (meJid) {
-            return meJid;
-        }
-        throw new Error(`${context} requires registered meJid`);
-    };
+    const dedup = new PromiseDedup();
     const resolveDirectFanoutDeviceJids = async (recipientJid, selfDeviceJidForRecipient) => {
         const recipientUserJid = toUserJid(recipientJid);
         const meUserJid = toUserJid(selfDeviceJidForRecipient);
         const targets = recipientUserJid === meUserJid ? [recipientUserJid] : [recipientUserJid, meUserJid];
         try {
             const synced = await signalDeviceSync.syncDeviceList(targets);
-            const byUser = new Map(synced.map((entry) => [toUserJid(entry.jid), entry.deviceJids]));
+            const byUser = new Map();
+            for (let index = 0; index < synced.length; index += 1) {
+                const entry = synced[index];
+                byUser.set(toUserJid(entry.jid), entry.deviceJids);
+            }
             const fanout = new Set();
             const recipientDevices = byUser.get(recipientUserJid) ?? [];
             if (recipientDevices.length === 0) {
@@ -45,7 +44,7 @@ export function createDeviceFanoutResolver(options) {
             return [recipientUserJid];
         }
     };
-    const resolveGroupParticipantDeviceJids = async (participantUserJids) => {
+    const resolveGroupParticipantDeviceJidsInternal = async (participantUserJids) => {
         const meDeviceJids = new Set();
         const meJid = getCurrentMeJid();
         if (meJid) {
@@ -71,7 +70,11 @@ export function createDeviceFanoutResolver(options) {
                 });
             }
         }
-        const candidateUsers = [...new Set(participantUserJids)];
+        const candidateUserSet = new Set();
+        for (let index = 0; index < participantUserJids.length; index += 1) {
+            candidateUserSet.add(participantUserJids[index]);
+        }
+        const candidateUsers = Array.from(candidateUserSet);
         if (candidateUsers.length === 0) {
             return [];
         }
@@ -89,6 +92,9 @@ export function createDeviceFanoutResolver(options) {
                 }
                 for (const deviceJid of entry.deviceJids) {
                     const normalizedDeviceJid = normalizeDeviceJid(deviceJid);
+                    if (isHostedDeviceJid(normalizedDeviceJid)) {
+                        continue;
+                    }
                     if (meDeviceJids.has(normalizedDeviceJid)) {
                         continue;
                     }
@@ -122,7 +128,10 @@ export function createDeviceFanoutResolver(options) {
         }
     };
     const resolveOwnPeerDeviceJids = async () => {
-        const meJid = requireCurrentMeJid('resolveOwnPeerDeviceJids');
+        const meJid = getCurrentMeJid();
+        if (!meJid) {
+            throw new Error('resolveOwnPeerDeviceJids requires registered meJid');
+        }
         const meUserJid = toUserJid(meJid);
         const meDevices = new Set();
         meDevices.add(normalizeDeviceJid(meJid));
@@ -177,6 +186,7 @@ export function createDeviceFanoutResolver(options) {
         }
         return meLid;
     };
+    const resolveGroupParticipantDeviceJids = (participantUserJids) => dedup.run(`group:${participantUserJids.join(',')}`, () => resolveGroupParticipantDeviceJidsInternal(participantUserJids));
     return {
         resolveDirectFanoutDeviceJids,
         resolveGroupParticipantDeviceJids,

package/dist/esm/client/messaging/participants.js

@@ -1,7 +1,9 @@
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { toUserJid } from '../../protocol/jid.js';
 import { toError } from '../../util/primitives.js';
 export function createGroupParticipantsCache(options) {
     const { participantsStore, queryGroupParticipantJids, logger } = options;
+    const dedup = new PromiseDedup();
     const sanitizeParticipantUsers = (participants) => {
         const deduped = new Set();
         for (const participant of participants) {
@@ -117,7 +119,7 @@ export function createGroupParticipantsCache(options) {
         }
         return sanitizeParticipantUsers(candidates);
     };
-    const refreshParticipantUsers = async (groupJid) => {
+    const refreshParticipantUsers = (groupJid) => dedup.run(`refresh:${groupJid}`, async () => {
         const queried = await queryGroupParticipantJids(groupJid);
         const participants = sanitizeParticipantUsers(queried);
         await participantsStore.upsertGroupParticipants({
@@ -126,14 +128,14 @@ export function createGroupParticipantsCache(options) {
             updatedAtMs: Date.now()
         });
         return participants;
-    };
-    const resolveParticipantUsers = async (groupJid) => {
+    });
+    const resolveParticipantUsers = (groupJid) => dedup.run(`resolve:${groupJid}`, async () => {
         const cached = await participantsStore.getGroupParticipants(groupJid);
         if (cached && cached.participants.length > 0) {
             return sanitizeParticipantUsers(cached.participants);
         }
         return refreshParticipantUsers(groupJid);
-    };
+    });
     const mutateFromGroupEvent = async (event) => {
         const groupJid = resolveGroupJidForParticipantCacheEvent(event);
         if (!groupJid) {

package/dist/esm/client/persistence/WriteBehindPersistence.js

@@ -0,0 +1,125 @@
+import { BackgroundQueue } from '../../infra/perf/BackgroundQueue.js';
+import { toError } from '../../util/primitives.js';
+function mergeThread(previous, incoming) {
+    return {
+        jid: incoming.jid,
+        name: incoming.name ?? previous.name,
+        unreadCount: incoming.unreadCount ?? previous.unreadCount,
+        archived: incoming.archived ?? previous.archived,
+        pinned: incoming.pinned ?? previous.pinned,
+        muteEndMs: incoming.muteEndMs ?? previous.muteEndMs,
+        markedAsUnread: incoming.markedAsUnread ?? previous.markedAsUnread,
+        ephemeralExpiration: incoming.ephemeralExpiration ?? previous.ephemeralExpiration
+    };
+}
+function mergeContact(previous, incoming) {
+    return {
+        jid: incoming.jid,
+        displayName: incoming.displayName ?? previous.displayName,
+        pushName: incoming.pushName ?? previous.pushName,
+        lid: incoming.lid ?? previous.lid,
+        phoneNumber: incoming.phoneNumber ?? previous.phoneNumber,
+        lastUpdatedMs: Math.max(previous.lastUpdatedMs, incoming.lastUpdatedMs)
+    };
+}
+export class WriteBehindPersistence {
+    constructor(stores, logger, options = {}) {
+        this.logger = logger;
+        this.flushTimeoutMs = options.flushTimeoutMs ?? 5000;
+        const queueOptions = (domain) => ({
+            maxPendingKeys: options.maxPendingKeys ?? 4096,
+            maxWriteConcurrency: options.maxWriteConcurrency ?? 4,
+            flushTimeoutMs: this.flushTimeoutMs,
+            onError: (key, error, attempt) => {
+                this.logger.warn('write-behind error', {
+                    domain,
+                    key,
+                    attempt,
+                    message: toError(error).message
+                });
+            },
+            onPressure: (pendingKeys) => {
+                this.logger.warn('write-behind pressure', {
+                    domain,
+                    pendingKeys
+                });
+            },
+            onDiscard: (key) => {
+                this.logger.warn('write-behind discarded pending write', {
+                    domain,
+                    key
+                });
+            }
+        });
+        this.queues = {
+            messages: new BackgroundQueue((_key, value) => stores.messageStore.upsert(value), queueOptions('messages')),
+            threads: new BackgroundQueue((_key, value) => stores.threadStore.upsert(value), {
+                ...queueOptions('threads'),
+                coalesce: (previous, incoming) => mergeThread(previous, incoming)
+            }),
+            contacts: new BackgroundQueue((_key, value) => stores.contactStore.upsert(value), {
+                ...queueOptions('contacts'),
+                coalesce: (previous, incoming) => mergeContact(previous, incoming)
+            })
+        };
+    }
+    persistMessage(record) {
+        this.queues.messages.enqueue(`msg:${record.id}`, record);
+    }
+    persistMessageAsync(record) {
+        return this.queues.messages.enqueueAsync(`msg:${record.id}`, record);
+    }
+    persistThread(record) {
+        this.queues.threads.enqueue(`thread:${record.jid}`, record);
+    }
+    persistThreadAsync(record) {
+        return this.queues.threads.enqueueAsync(`thread:${record.jid}`, record);
+    }
+    persistContact(record) {
+        this.queues.contacts.enqueue(`contact:${record.jid}`, record);
+    }
+    persistContactAsync(record) {
+        return this.queues.contacts.enqueueAsync(`contact:${record.jid}`, record);
+    }
+    async flush(timeoutMs = this.flushTimeoutMs) {
+        const [messages, threads, contacts] = await Promise.all([
+            this.queues.messages.flush(timeoutMs),
+            this.queues.threads.flush(timeoutMs),
+            this.queues.contacts.flush(timeoutMs)
+        ]);
+        const result = this.toDrainResult(messages, threads, contacts);
+        if (result.remaining > 0) {
+            this.logger.warn('write-behind flush finished with pending writes', {
+                messagesRemaining: messages.remaining,
+                threadsRemaining: threads.remaining,
+                contactsRemaining: contacts.remaining
+            });
+        }
+        return result;
+    }
+    async destroy(timeoutMs = this.flushTimeoutMs) {
+        const [messages, threads, contacts] = await Promise.all([
+            this.queues.messages.destroy(timeoutMs),
+            this.queues.threads.destroy(timeoutMs),
+            this.queues.contacts.destroy(timeoutMs)
+        ]);
+        const result = this.toDrainResult(messages, threads, contacts);
+        if (result.remaining > 0) {
+            this.logger.warn('write-behind destroy finished with pending writes', {
+                messagesRemaining: messages.remaining,
+                threadsRemaining: threads.remaining,
+                contactsRemaining: contacts.remaining
+            });
+        }
+        return result;
+    }
+    toDrainResult(messages, threads, contacts) {
+        return {
+            messages,
+            threads,
+            contacts,
+            flushed: messages.flushed + threads.flushed + contacts.flushed,
+            remaining: messages.remaining + threads.remaining + contacts.remaining
+        };
+    }
+}

package/dist/esm/client/tokens/cs-token.js

@@ -0,0 +1,46 @@
+import { hmacSign, importHmacKey } from '../../crypto/core/index.js';
+import { TEXT_ENCODER } from '../../util/bytes.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
+const CS_TOKEN_CACHE_MAX = 5;
+export class CsTokenGenerator {
+    constructor() {
+        this.cachedKey = null;
+        this.cachedSalt = null;
+        this.cache = new Map();
+    }
+    async generate(nctSalt, accountLid) {
+        const cached = this.cache.get(accountLid);
+        if (cached && this.isSameSalt(nctSalt)) {
+            return cached;
+        }
+        const key = await this.resolveKey(nctSalt);
+        const result = await hmacSign(key, TEXT_ENCODER.encode(accountLid));
+        setBoundedMapEntry(this.cache, accountLid, result, CS_TOKEN_CACHE_MAX);
+        return result;
+    }
+    invalidate() {
+        this.cachedKey = null;
+        this.cachedSalt = null;
+        this.cache.clear();
+    }
+    isSameSalt(salt) {
+        if (!this.cachedSalt || this.cachedSalt.length !== salt.length) {
+            return false;
+        }
+        for (let i = 0; i < salt.length; i += 1) {
+            if (this.cachedSalt[i] !== salt[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async resolveKey(salt) {
+        if (this.cachedKey && this.isSameSalt(salt)) {
+            return this.cachedKey;
+        }
+        this.cachedKey = await importHmacKey(salt);
+        this.cachedSalt = salt;
+        this.cache.clear();
+        return this.cachedKey;
+    }
+}

package/dist/esm/client/tokens/tc-token.js

@@ -0,0 +1,18 @@
+export function computeBucket(unixTimeS, durationS) {
+    return Math.floor(unixTimeS / durationS);
+}
+export function tokenExpirationCutoffS(nowS, durationS, numBuckets) {
+    const currentBucket = computeBucket(nowS, durationS);
+    const cutoffBucket = currentBucket - numBuckets;
+    return cutoffBucket * durationS;
+}
+export function isTokenExpired(tokenTimestampS, nowS, durationS, numBuckets) {
+    const cutoff = tokenExpirationCutoffS(nowS, durationS, numBuckets);
+    return tokenTimestampS < cutoff;
+}
+export function shouldSendNewToken(senderTimestampS, nowS, senderDurationS) {
+    return computeBucket(senderTimestampS, senderDurationS) !== computeBucket(nowS, senderDurationS);
+}
+export function clampDuration(durationS, maxDurationS) {
+    return Math.min(durationS, maxDurationS);
+}

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

@@ -6,5 +6,5 @@ export { X25519 } from '../curves/X25519.js';
 export { hkdf, hkdfSplit } from '../core/hkdf.js';
 export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent } from '../core/keys.js';
 export { buildNonce } from '../core/nonce.js';
-export { randomBytesAsync, randomIntAsync } from '../core/random.js';
-export { sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt, ed25519VerifyRaw } from '../core/primitives.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';

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

@@ -1,5 +1,5 @@
-import { SERIALIZED_PUB_KEY_PREFIX } from '../core/constants.js';
 import { assertByteLength } from '../../util/bytes.js';
+const SERIALIZED_PUB_KEY_PREFIX = 5;
 /**
  * Converts a 32-byte raw public key to 33-byte serialized format (with 0x05 prefix)
  */

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

@@ -1,5 +1,7 @@
 /**
  * Builds a 12-byte nonce for AES-GCM encryption with counter in the last 4 bytes.
+ * Allocates a new buffer per call because concurrent Noise encrypt/decrypt operations
+ * may hold references to different nonces simultaneously.
  * Throws if counter exceeds uint32 range to prevent nonce reuse.
  */
 export function buildNonce(counter) {

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

@@ -90,10 +90,3 @@ export async function aesCtrEncrypt(key, counter, plaintext) {
 export async function aesCtrDecrypt(key, counter, ciphertext) {
     return toBytesView(await webcrypto.subtle.decrypt({ name: 'AES-CTR', counter, length: 64 }, key, ciphertext));
 }
-// ============================================
-// Ed25519 raw verify (for Signal variant sigs)
-// ============================================
-export async function ed25519VerifyRaw(publicKey, signature, message) {
-    const cryptoKey = await webcrypto.subtle.importKey('raw', publicKey, { name: 'Ed25519' }, false, ['verify']);
-    return webcrypto.subtle.verify('Ed25519', cryptoKey, signature, message);
-}

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

@@ -1,4 +1,4 @@
-import { randomBytes, randomInt } from 'node:crypto';
+import { randomBytes, randomFill, randomInt } from 'node:crypto';
 import { promisify } from 'node:util';
 import { toBytesView } from '../../util/bytes.js';
 const randomBytesAsyncImpl = promisify(randomBytes);
@@ -6,4 +6,25 @@ 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) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        };
+        if (offset === undefined) {
+            randomFill(target, onDone);
+            return;
+        }
+        if (size === undefined) {
+            randomFill(target, offset, onDone);
+            return;
+        }
+        randomFill(target, offset, size, onDone);
+    });
+    return target;
+}
 export const randomIntAsync = randomIntAsyncImpl;

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

@@ -1,9 +1,24 @@
 import { webcrypto } from 'node:crypto';
 import { X25519_PKCS8_PREFIX } from '../curves/constants.js';
 import { pkcs8FromRawPrivate } from '../curves/types.js';
-import { bigIntToBytesLE, bytesToBigIntLE } from '../math/le.js';
-import { FIELD_P, mod, modInv } from '../math/mod.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';
+// Pre-allocated temps for montgomeryToEdwardsPublic (safe: single-threaded)
+const _mx = fe();
+const _m1 = fe();
+const _m2 = fe();
+const _m3 = fe();
+// p-1 = 2^255-20 in LE bytes: 0xEC, 0xFF×30, 0x7F
+// Mask bit 255 before comparing (non-canonical inputs may have it set)
+function isFieldPMinus1(b) {
+    if (b[0] !== 0xec || (b[31] & 0x7f) !== 0x7f)
+        return false;
+    for (let i = 1; i < 31; i++)
+        if (b[i] !== 0xff)
+            return false;
+    return true;
+}
 export function clampCurvePrivateKeyInPlace(privateKey) {
     assertByteLength(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
     privateKey[0] &= 248;
@@ -13,12 +28,16 @@ export function clampCurvePrivateKeyInPlace(privateKey) {
 }
 export function montgomeryToEdwardsPublic(curvePublicKey, signBit) {
     assertByteLength(curvePublicKey, 32, `invalid curve25519 public key length ${curvePublicKey.length}`);
-    const x = bytesToBigIntLE(curvePublicKey);
-    if (x === FIELD_P - 1n) {
+    if (isFieldPMinus1(curvePublicKey)) {
         throw new Error('invalid curve25519 low-order public key');
     }
-    const y = mod((x - 1n) * modInv(x + 1n));
-    const encoded = bigIntToBytesLE(y, 32);
+    feFromBytes(_mx, curvePublicKey);
+    feSub(_m1, _mx, FE_ONE);
+    feAdd(_m2, _mx, FE_ONE);
+    feInv(_m3, _m2);
+    feMul(_m1, _m1, _m3);
+    const encoded = new Uint8Array(32);
+    fePack(encoded, _m1);
     encoded[31] = (encoded[31] & 0x7f) | (signBit & 0x80);
     return encoded;
 }

package/dist/esm/crypto/index.js

@@ -1 +1,2 @@
 export * from './core/index.js';
+export { X25519 } from './curves/X25519.js';

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

@@ -1,41 +1,18 @@
+import { fe, feFromBigInt } from '../math/fe.js';
 export const FIELD_P = (1n << 255n) - 19n;
 export const GROUP_L = (1n << 252n) + 27742317777372353535851937790883648493n;
-function modField(value) {
-    const remainder = value % FIELD_P;
-    return remainder >= 0n ? remainder : remainder + FIELD_P;
-}
-function modPowField(base, exponent) {
-    let result = 1n;
-    let current = modField(base);
-    let power = exponent;
-    while (power > 0n) {
-        if ((power & 1n) === 1n) {
-            result = modField(result * current);
-        }
-        current = modField(current * current);
-        power >>= 1n;
-    }
-    return result;
-}
-function modInvField(value) {
-    if (value === 0n) {
-        throw new Error('field inversion by zero');
-    }
-    return modPowField(value, FIELD_P - 2n);
-}
-const BASE_X = 15112221349535400772501151409588531511454012693041857206046113283949847762202n;
-const BASE_Y = 46316835694926478169428394003475163141307993866256225615783033603165251855960n;
-export const EDWARDS_D = modField(-121665n * modInvField(121666n));
-export const TWO_D = modField(2n * EDWARDS_D);
+export const FE_TWO_D = feFromBigInt(16295367250680780974490674513165176452449235426866156013048779062215315747161n);
+export const FE_ZERO = fe();
+export const FE_ONE = feFromBigInt(1n);
 export const BASE_POINT = Object.freeze({
-    x: BASE_X,
-    y: BASE_Y,
-    z: 1n,
-    t: modField(BASE_X * BASE_Y)
+    x: feFromBigInt(15112221349535400772501151409588531511454012693041857206046113283949847762202n),
+    y: feFromBigInt(46316835694926478169428394003475163141307993866256225615783033603165251855960n),
+    z: feFromBigInt(1n),
+    t: feFromBigInt(46827403850823179245072216630277197565144205554125654976674165829533817101731n)
 });
 export const IDENTITY_POINT = Object.freeze({
-    x: 0n,
-    y: 1n,
-    z: 1n,
-    t: 0n
+    x: feFromBigInt(0n),
+    y: feFromBigInt(1n),
+    z: feFromBigInt(1n),
+    t: feFromBigInt(0n)
 });