zapo-js 0.1.1 → 0.2.0

package/dist/types/client/coordinators/WaProfileCoordinator.d.ts

@@ -0,0 +1,36 @@
+import type { WaProfilePictureType } from '../../transport/node/builders/profile';
+import type { BinaryNode } from '../../transport/types';
+export interface WaProfilePictureResult {
+    readonly url?: string;
+    readonly directPath?: string;
+    readonly id?: string;
+    readonly type?: string;
+}
+export interface WaProfileStatusResult {
+    readonly status: string | null;
+}
+export interface WaProfileInfo {
+    readonly jid: string;
+    readonly pictureId?: number;
+    readonly status?: string | null;
+}
+export interface WaDisappearingModeResult {
+    readonly duration: number;
+    readonly timestamp: number;
+    readonly ephemeralityDisabled?: boolean;
+}
+export interface WaProfileCoordinator {
+    readonly getProfilePicture: (jid: string, type?: WaProfilePictureType, existingId?: string) => Promise<WaProfilePictureResult>;
+    readonly setProfilePicture: (imageBytes: Uint8Array, targetJid?: string) => Promise<string | null>;
+    readonly deleteProfilePicture: (targetJid?: string) => Promise<void>;
+    readonly getStatus: (jid: string) => Promise<WaProfileStatusResult>;
+    readonly setStatus: (text: string) => Promise<void>;
+    readonly getProfiles: (jids: readonly string[]) => Promise<readonly WaProfileInfo[]>;
+    readonly getDisappearingMode: (jids: readonly string[]) => Promise<readonly WaDisappearingModeResult[]>;
+}
+interface WaProfileCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly generateSid: () => Promise<string>;
+}
+export declare function createProfileCoordinator(options: WaProfileCoordinatorOptions): WaProfileCoordinator;
+export {};

package/dist/types/client/coordinators/WaRetryCoordinator.d.ts

@@ -38,6 +38,8 @@ export declare class WaRetryCoordinator {
     private readonly getCurrentMeLid;
     private readonly getCurrentSignedIdentity;
     private readonly retryProcessingByMessageId;
+    private readonly retrySessionBaseKeys;
+    private nextRetryCleanupAtMs;
     constructor(options: WaRetryCoordinatorOptions);
     onDecryptFailure(context: WaRetryDecryptFailureContext, error: unknown): Promise<boolean>;
     handleIncomingRetryReceipt(receiptNode: BinaryNode): Promise<void>;
@@ -51,11 +53,17 @@ export declare class WaRetryCoordinator {
     private runRetryTaskSerialized;
     private buildRetryKeysSection;
     private updateLocalSessionFromRetryRequest;
+    private applySessionBaseKeyPolicy;
     private markRetryRequesterSenderKeyAsStale;
     private fetchMissingPreKeysSession;
     private authorizeRetryRequest;
     private isRequesterAuthorizedDevice;
     private mapOutboundStateFromReceiptType;
     private sendRetryAckSafe;
+    private maybeCleanupRetryStore;
+    private retrySessionBaseKeyMapKey;
+    private setRetrySessionBaseKey;
+    private getRetrySessionBaseKey;
+    private cleanupRetrySessionBaseKeys;
 }
 export {};

package/dist/types/client/coordinators/WaStreamControlCoordinator.d.ts

@@ -1,4 +1,5 @@
 import type { Logger } from '../../infra/log/types';
+import type { WaConnectionCode, WaConnectionOpenReason, WaDisconnectReason } from '../../protocol/stream';
 import type { WaStreamControlNodeResult } from '../../transport/stream/parse';
 import type { WaComms } from '../../transport/WaComms';
 interface WaStreamControlCoordinatorOptions {
@@ -6,9 +7,9 @@ interface WaStreamControlCoordinatorOptions {
     readonly getComms: () => WaComms | null;
     readonly clearPendingQueries: (error: Error) => void;
     readonly clearMediaConnCache: () => void;
-    readonly disconnect: () => Promise<void>;
+    readonly disconnect: (reason: WaDisconnectReason, isLogout: boolean, code: WaConnectionCode | null) => Promise<void>;
     readonly clearStoredCredentials: () => Promise<void>;
-    readonly connect: () => Promise<void>;
+    readonly connect: (reason: WaConnectionOpenReason) => Promise<void>;
 }
 export interface WaStreamControlHandler {
     readonly handleStreamControlResult: (result: WaStreamControlNodeResult) => Promise<void>;

package/dist/types/client/coordinators/WaTrustedContactTokenCoordinator.d.ts

@@ -0,0 +1,45 @@
+import type { ParsedPrivacyToken } from '../events/privacy-token';
+import type { WaClientEventMap } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaPrivacyTokenStore } from '../../store/contracts/privacy-token.store';
+import type { BinaryNode } from '../../transport/types';
+type WaTrustedContactTokenRuntime = {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly getCurrentMeLid: () => string | null;
+};
+export declare class WaTrustedContactTokenCoordinator {
+    private readonly logger;
+    private readonly store;
+    private readonly runtime;
+    private readonly config;
+    private readonly csTokenGenerator;
+    private readonly senderTokenDedup;
+    private cachedNctSalt;
+    private nctSaltHydrated;
+    constructor(options: {
+        readonly logger: Logger;
+        readonly store: WaPrivacyTokenStore;
+        readonly runtime: WaTrustedContactTokenRuntime;
+        readonly durationS?: number;
+        readonly numBuckets?: number;
+        readonly senderDurationS?: number;
+        readonly senderNumBuckets?: number;
+        readonly maxDurationS?: number;
+    });
+    resolveTokenForMessage(recipientJid: string): Promise<BinaryNode | null>;
+    handleIncomingToken(fromJid: string, tokens: readonly ParsedPrivacyToken[]): Promise<void>;
+    maybeIssueSenderToken(recipientJid: string): Promise<void>;
+    reissueOnIdentityChange(jid: string): Promise<void>;
+    hydrateFromHistorySync(conversations: readonly {
+        readonly jid: string;
+        readonly tcToken?: Uint8Array | null;
+        readonly tcTokenTimestamp?: number | null;
+        readonly tcTokenSenderTimestamp?: number | null;
+    }[]): Promise<void>;
+    handleNctSaltSync(salt: Uint8Array | null): Promise<void>;
+    hydrateNctSaltFromHistorySync(salt: Uint8Array): Promise<void>;
+    private getNctSalt;
+    private issuePrivacyToken;
+}
+export {};

package/dist/types/client/dirty.d.ts

@@ -11,6 +11,7 @@ interface WaDirtySyncRuntime {
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
     readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly syncAppState: () => Promise<void>;
+    readonly generateUsyncSid: () => Promise<string>;
 }
 export declare function parseDirtyBits(nodes: readonly BinaryNode[], logger: Logger): readonly WaDirtyBit[];
 export declare function handleDirtyBits(runtime: WaDirtySyncRuntime, dirtyBits: readonly WaDirtyBit[]): Promise<void>;

package/dist/types/client/events/devices.d.ts

@@ -0,0 +1,20 @@
+import type { BinaryNode } from '../../transport/types';
+export declare const DEVICE_NOTIFICATION_ACTIONS: Readonly<{
+    readonly ADD: "add";
+    readonly REMOVE: "remove";
+    readonly UPDATE: "update";
+}>;
+export type DeviceNotificationAction = (typeof DEVICE_NOTIFICATION_ACTIONS)[keyof typeof DEVICE_NOTIFICATION_ACTIONS];
+export interface DeviceNotificationDevice {
+    readonly deviceId: number;
+    readonly keyIndex: number | null;
+}
+export interface DeviceNotification {
+    readonly action: DeviceNotificationAction;
+    readonly stanzaId: string;
+    readonly fromJid: string;
+    readonly lid: string | undefined;
+    readonly hash: string | undefined;
+    readonly devices: readonly DeviceNotificationDevice[];
+}
+export declare function parseDeviceNotification(node: BinaryNode): DeviceNotification | null;

package/dist/types/client/events/group.d.ts

@@ -1,7 +1,8 @@
-import type { WaGroupEvent, WaIncomingUnhandledStanzaEvent } from '../types';
+import type { WaGroupEvent, WaGroupEventParticipant, WaIncomingUnhandledStanzaEvent } from '../types';
 import type { BinaryNode } from '../../transport/types';
 export interface WaParseGroupNotificationResult {
     readonly events: readonly WaGroupEvent[];
     readonly unhandled: readonly WaIncomingUnhandledStanzaEvent[];
 }
+export declare function parseParticipants(node: BinaryNode): readonly WaGroupEventParticipant[];
 export declare function parseGroupNotificationEvents(notificationNode: BinaryNode): WaParseGroupNotificationResult;

package/dist/types/client/events/identity.d.ts

@@ -0,0 +1,9 @@
+import type { BinaryNode } from '../../transport/types';
+export interface IdentityChangeNotification {
+    readonly fromJid: string;
+    readonly stanzaId: string;
+    readonly displayName: string | undefined;
+    readonly lid: string | undefined;
+    readonly offline: string | undefined;
+}
+export declare function parseIdentityChangeNotification(node: BinaryNode): IdentityChangeNotification | null;

package/dist/types/client/events/privacy-token.d.ts

@@ -0,0 +1,7 @@
+import type { BinaryNode } from '../../transport/types';
+export interface ParsedPrivacyToken {
+    readonly type: string;
+    readonly tokenBytes: Uint8Array;
+    readonly timestampS: number;
+}
+export declare function parsePrivacyTokenNotification(node: BinaryNode): readonly ParsedPrivacyToken[];

package/dist/types/client/history-sync.d.ts

@@ -1,17 +1,20 @@
+import type { WriteBehindPersistence } from './persistence/WriteBehindPersistence';
 import type { WaClientEventMap } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import { type Proto } from '..';
-import type { WaContactStore } from '../store/contracts/contact.store';
-import type { WaMessageStore } from '../store/contracts/message.store';
-import type { WaThreadStore } from '../store/contracts/thread.store';
 interface WaHistorySyncDeps {
     readonly logger: Logger;
     readonly mediaTransfer: WaMediaTransferClient;
-    readonly contactStore: WaContactStore;
-    readonly messageStore: WaMessageStore;
-    readonly threadStore: WaThreadStore;
+    readonly writeBehind: WriteBehindPersistence;
     readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly onPrivacyTokens?: (conversations: readonly {
+        readonly jid: string;
+        readonly tcToken?: Uint8Array | null;
+        readonly tcTokenTimestamp?: number | null;
+        readonly tcTokenSenderTimestamp?: number | null;
+    }[]) => Promise<void>;
+    readonly onNctSalt?: (salt: Uint8Array) => Promise<void>;
 }
 export declare function processHistorySyncNotification(deps: WaHistorySyncDeps, notification: Proto.Message.IHistorySyncNotification): Promise<void>;
 export {};

package/dist/types/client/incoming.d.ts

@@ -1,5 +1,6 @@
 import type { WaIncomingBaseEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaGroupEvent } from './types';
 import type { Logger } from '../infra/log/types';
+import type { WaConnectionCode, WaDisconnectReason } from '../protocol/stream';
 import type { BinaryNode } from '../transport/types';
 interface IncomingAckRuntime {
     readonly logger: Logger;
@@ -13,7 +14,8 @@ type IncomingReceiptHandlerOptions = IncomingAckRuntime & {
 type IncomingFailureHandlerOptions = {
     readonly logger: Logger;
     readonly emitIncomingFailure: (event: WaIncomingFailureEvent) => void;
-    readonly disconnect: () => Promise<void>;
+    readonly stopComms: () => void;
+    readonly disconnect: (reason: WaDisconnectReason, isLogout: boolean, code: WaConnectionCode | null) => Promise<void>;
     readonly clearStoredCredentials: () => Promise<void>;
 };
 type IncomingNotificationHandlerOptions = IncomingAckRuntime & {

package/dist/types/client/index.d.ts

@@ -1,2 +1,2 @@
 export { WaClient } from './WaClient';
-export type { WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from './types';
+export type { WaAppStateMessageKey, WaClientProxyOptions, WaClearChatOptions, WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaConnectionEvent, WaDeleteChatOptions, WaDeleteMessageForMeOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions, WaLogoutStoreClearOptions, WaWriteBehindOptions } from './types';

package/dist/types/client/mailbox.d.ts

@@ -1,12 +1,10 @@
+import type { WriteBehindPersistence } from './persistence/WriteBehindPersistence';
 import type { WaIncomingMessageEvent } from './types';
 import type { Logger } from '../infra/log/types';
-import type { WaContactStore } from '../store/contracts/contact.store';
-import type { WaMessageStore } from '../store/contracts/message.store';
 interface WaPersistIncomingMailboxOptions {
     readonly logger: Logger;
-    readonly contactStore: WaContactStore;
-    readonly messageStore: WaMessageStore;
+    readonly writeBehind: WriteBehindPersistence;
     readonly event: WaIncomingMessageEvent;
 }
-export declare function persistIncomingMailboxEntities(options: WaPersistIncomingMailboxOptions): Promise<void>;
+export declare function persistIncomingMailboxEntities(options: WaPersistIncomingMailboxOptions): void;
 export {};

package/dist/types/client/messages.d.ts

@@ -4,7 +4,7 @@ import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { WaSendMessageContent } from '../message/types';
 import type { Proto } from '..';
 import type { BinaryNode } from '../transport/types';
-interface WaMediaMessageOptions {
+export interface WaMediaMessageOptions {
     readonly logger: Logger;
     readonly mediaTransfer: WaMediaTransferClient;
     readonly iqTimeoutMs?: number;
@@ -14,4 +14,3 @@ interface WaMediaMessageOptions {
 }
 export declare function buildMediaMessageContent(options: WaMediaMessageOptions, content: WaSendMessageContent): Promise<Proto.IMessage>;
 export declare function getMediaConn(options: WaMediaMessageOptions, forceRefresh?: boolean): Promise<WaMediaConn>;
-export {};

package/dist/types/client/messaging/fanout.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from '../../infra/log/types';
+import type { SignalDeviceSyncApi } from '../../signal/api/SignalDeviceSyncApi';
+export type DeviceFanoutResolver = {
+    resolveDirectFanoutDeviceJids(recipientJid: string, selfDeviceJid: string): Promise<readonly string[]>;
+    resolveGroupParticipantDeviceJids(participantUserJids: readonly string[]): Promise<readonly string[]>;
+    resolveOwnPeerDeviceJids(): Promise<readonly string[]>;
+    resolveSelfDeviceJidForRecipient(recipientJid: string, meJid: string, meLid: string | null | undefined): string;
+};
+export declare function createDeviceFanoutResolver(options: {
+    readonly signalDeviceSync: SignalDeviceSyncApi;
+    readonly getCurrentMeJid: () => string | null | undefined;
+    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly logger: Logger;
+}): DeviceFanoutResolver;

package/dist/types/client/messaging/key-protocol.d.ts

@@ -0,0 +1,18 @@
+import type { WaAppStateSyncKey } from '../../appstate/types';
+import type { DeviceFanoutResolver } from '../messaging/fanout';
+import type { WaSignalMessagePublishInput } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMessagePublishOptions, WaMessagePublishResult } from '../../message/types';
+type PublishSignalMessageFn = (input: WaSignalMessagePublishInput, options?: WaMessagePublishOptions) => Promise<WaMessagePublishResult>;
+export type AppStateSyncKeyProtocol = {
+    requestKeys(keyIds: readonly Uint8Array[]): Promise<readonly string[]>;
+    sendKeyShare(toDeviceJid: string, keys: readonly WaAppStateSyncKey[], missingKeyIds?: readonly Uint8Array[]): Promise<void>;
+};
+export declare function createAppStateSyncKeyProtocol(options: {
+    readonly publishSignalMessage: PublishSignalMessageFn;
+    readonly fanoutResolver: DeviceFanoutResolver;
+    readonly getCurrentMeJid: () => string | null | undefined;
+    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly logger: Logger;
+}): AppStateSyncKeyProtocol;
+export {};

package/dist/types/client/messaging/participants.d.ts

@@ -0,0 +1,13 @@
+import type { WaGroupEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaParticipantsStore } from '../../store/contracts/participants.store';
+export type GroupParticipantsCache = {
+    resolveParticipantUsers(groupJid: string): Promise<readonly string[]>;
+    refreshParticipantUsers(groupJid: string): Promise<readonly string[]>;
+    mutateFromGroupEvent(event: WaGroupEvent): Promise<void>;
+};
+export declare function createGroupParticipantsCache(options: {
+    readonly participantsStore: WaParticipantsStore;
+    readonly queryGroupParticipantJids: (groupJid: string) => Promise<readonly string[]>;
+    readonly logger: Logger;
+}): GroupParticipantsCache;

package/dist/types/client/persistence/WriteBehindPersistence.d.ts

@@ -0,0 +1,34 @@
+import type { WaWriteBehindOptions } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { BackgroundQueueFlushResult } from '../../infra/perf/BackgroundQueue';
+import type { WaContactStore, WaStoredContactRecord } from '../../store/contracts/contact.store';
+import type { WaMessageStore, WaStoredMessageRecord } from '../../store/contracts/message.store';
+import type { WaStoredThreadRecord, WaThreadStore } from '../../store/contracts/thread.store';
+interface WriteBehindStores {
+    readonly messageStore: WaMessageStore;
+    readonly threadStore: WaThreadStore;
+    readonly contactStore: WaContactStore;
+}
+export interface WriteBehindDrainResult {
+    readonly messages: BackgroundQueueFlushResult;
+    readonly threads: BackgroundQueueFlushResult;
+    readonly contacts: BackgroundQueueFlushResult;
+    readonly flushed: number;
+    readonly remaining: number;
+}
+export declare class WriteBehindPersistence {
+    private readonly logger;
+    private readonly queues;
+    private readonly flushTimeoutMs;
+    constructor(stores: WriteBehindStores, logger: Logger, options?: WaWriteBehindOptions);
+    persistMessage(record: WaStoredMessageRecord): void;
+    persistMessageAsync(record: WaStoredMessageRecord): Promise<void>;
+    persistThread(record: WaStoredThreadRecord): void;
+    persistThreadAsync(record: WaStoredThreadRecord): Promise<void>;
+    persistContact(record: WaStoredContactRecord): void;
+    persistContactAsync(record: WaStoredContactRecord): Promise<void>;
+    flush(timeoutMs?: number): Promise<WriteBehindDrainResult>;
+    destroy(timeoutMs?: number): Promise<WriteBehindDrainResult>;
+    private toDrainResult;
+}
+export {};

package/dist/types/client/tokens/cs-token.d.ts

@@ -0,0 +1,10 @@
+export declare class CsTokenGenerator {
+    private cachedKey;
+    private cachedSalt;
+    private readonly cache;
+    constructor();
+    generate(nctSalt: Uint8Array, accountLid: string): Promise<Uint8Array>;
+    invalidate(): void;
+    private isSameSalt;
+    private resolveKey;
+}

package/dist/types/client/tokens/tc-token.d.ts

@@ -0,0 +1,5 @@
+export declare function computeBucket(unixTimeS: number, durationS: number): number;
+export declare function tokenExpirationCutoffS(nowS: number, durationS: number, numBuckets: number): number;
+export declare function isTokenExpired(tokenTimestampS: number, nowS: number, durationS: number, numBuckets: number): boolean;
+export declare function shouldSendNewToken(senderTimestampS: number, nowS: number, senderDurationS: number): boolean;
+export declare function clampDuration(durationS: number, maxDurationS: number): number;

package/dist/types/client/types.d.ts

@@ -2,11 +2,31 @@ import type { AppStateCollectionName } from '../appstate/types';
 import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions } from '../auth/types';
 import type { WaMessagePublishOptions } from '../message/types';
 import type { Proto } from '..';
+import type { WaConnectionCode, WaConnectionOpenReason, WaDisconnectReason } from '../protocol/stream';
 import type { WaStore } from '../store/types';
-import type { BinaryNode } from '../transport/types';
+import type { BinaryNode, WaProxyTransport } from '../transport/types';
+export interface WaClientProxyOptions {
+    readonly ws?: WaProxyTransport;
+    readonly mediaUpload?: WaProxyTransport;
+    readonly mediaDownload?: WaProxyTransport;
+}
+export interface WaLogoutStoreClearOptions {
+    readonly auth?: boolean;
+    readonly signal?: boolean;
+    readonly senderKey?: boolean;
+    readonly appState?: boolean;
+    readonly retry?: boolean;
+    readonly participants?: boolean;
+    readonly deviceList?: boolean;
+    readonly messages?: boolean;
+    readonly threads?: boolean;
+    readonly contacts?: boolean;
+    readonly privacyToken?: boolean;
+}
 export interface WaClientOptions extends WaAuthClientOptions, WaAuthSocketOptions {
     readonly store: WaStore;
     readonly sessionId: string;
+    readonly proxy?: WaClientProxyOptions;
     readonly chatSocketUrls?: readonly string[];
     readonly iqTimeoutMs?: number;
     readonly nodeQueryTimeoutMs?: number;
@@ -18,10 +38,25 @@ export interface WaClientOptions extends WaAuthClientOptions, WaAuthSocketOption
     readonly messageAckTimeoutMs?: number;
     readonly messageMaxAttempts?: number;
     readonly messageRetryDelayMs?: number;
+    readonly writeBehind?: WaWriteBehindOptions;
     readonly history?: WaHistorySyncOptions;
     readonly chatEvents?: {
         readonly emitSnapshotMutations?: boolean;
     };
+    readonly privacyToken?: WaPrivacyTokenOptions;
+    readonly logoutStoreClear?: WaLogoutStoreClearOptions;
+}
+export interface WaPrivacyTokenOptions {
+    readonly tcTokenDurationS?: number;
+    readonly tcTokenNumBuckets?: number;
+    readonly tcTokenSenderDurationS?: number;
+    readonly tcTokenSenderNumBuckets?: number;
+    readonly tcTokenMaxDurationS?: number;
+}
+export interface WaWriteBehindOptions {
+    readonly maxPendingKeys?: number;
+    readonly maxWriteConcurrency?: number;
+    readonly flushTimeoutMs?: number;
 }
 export interface WaHistorySyncOptions {
     readonly enabled?: boolean;
@@ -41,6 +76,24 @@ export interface WaSignalMessagePublishInput {
 export interface WaSendMessageOptions extends WaMessagePublishOptions {
     readonly id?: string;
     readonly expectedIdentity?: Uint8Array;
+    readonly subtype?: string;
+}
+export interface WaClearChatOptions {
+    readonly deleteStarred?: boolean;
+    readonly deleteMedia?: boolean;
+}
+export interface WaDeleteChatOptions {
+    readonly deleteMedia?: boolean;
+}
+export interface WaAppStateMessageKey {
+    readonly chatJid: string;
+    readonly id: string;
+    readonly fromMe: boolean;
+    readonly participantJid?: string;
+}
+export interface WaDeleteMessageForMeOptions {
+    readonly deleteMedia?: boolean;
+    readonly messageTimestampMs?: number;
 }
 export type WaIncomingNodeHandler = (node: BinaryNode) => Promise<boolean>;
 export interface WaIncomingNodeHandlerRegistration {
@@ -178,7 +231,19 @@ export interface WaChatEvent {
     readonly locked?: boolean;
     readonly deviceAgentId?: string;
 }
-export type WaEmptyEvent = Readonly<Record<string, never>>;
+export type WaConnectionEvent = {
+    readonly status: 'open';
+    readonly reason: WaConnectionOpenReason;
+    readonly code: null;
+    readonly isLogout: false;
+    readonly isNewLogin: boolean;
+} | {
+    readonly status: 'close';
+    readonly reason: WaDisconnectReason;
+    readonly code: WaConnectionCode | null;
+    readonly isLogout: boolean;
+    readonly isNewLogin: false;
+};
 export interface WaClientEventMap {
     readonly auth_qr: (event: {
         readonly qr: string;
@@ -199,8 +264,7 @@ export interface WaClientEventMap {
     readonly client_error: (event: {
         readonly error: Error;
     }) => void;
-    readonly connection_open: (event: WaEmptyEvent) => void;
-    readonly connection_close: (event: WaEmptyEvent) => void;
+    readonly connection: (event: WaConnectionEvent) => void;
     readonly transport_frame_in: (event: {
         readonly frame: Uint8Array;
     }) => void;
@@ -232,4 +296,11 @@ export interface WaClientEventMap {
     readonly group_event: (event: WaGroupEvent) => void;
     readonly chat_event: (event: WaChatEvent) => void;
     readonly history_sync_chunk: (event: WaHistorySyncChunkEvent) => void;
+    readonly privacy_token_update: (event: WaPrivacyTokenUpdateEvent) => void;
+}
+export interface WaPrivacyTokenUpdateEvent {
+    readonly jid: string;
+    readonly timestampS: number;
+    readonly type: string;
+    readonly source: 'notification' | 'history_sync';
 }

package/dist/types/crypto/core/hkdf.d.ts

@@ -1,8 +1,2 @@
-/**
- * HKDF key derivation using SHA-256
- */
 export declare function hkdf(ikm: Uint8Array, salt: Uint8Array | null, info: Uint8Array | string, outLength: number): Promise<Uint8Array>;
-/**
- * HKDF key derivation that outputs two 32-byte keys
- */
 export declare function hkdfSplit(ikm: Uint8Array, salt: Uint8Array | null, info: string): Promise<readonly [Uint8Array, Uint8Array]>;

package/dist/types/crypto/core/index.d.ts

@@ -3,9 +3,8 @@
  */
 export { Ed25519 } from '../curves/Ed25519';
 export { X25519 } from '../curves/X25519';
-export { decodeBase64Url, assert32 } from '../core/encoding';
 export { hkdf, hkdfSplit } from '../core/hkdf';
 export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent } from '../core/keys';
 export { buildNonce } from '../core/nonce';
-export { randomBytesAsync, randomIntAsync } from '../core/random';
-export { type CryptoKey, sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt, ed25519VerifyRaw } from '../core/primitives';
+export { randomBytesAsync, randomFillAsync, randomIntAsync } from '../core/random';
+export { type CryptoKey, sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt } from '../core/primitives';

package/dist/types/crypto/core/nonce.d.ts

@@ -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 declare function buildNonce(counter: number): Uint8Array;

package/dist/types/crypto/core/primitives.d.ts

@@ -22,4 +22,3 @@ export declare function hmacSign(key: webcrypto.CryptoKey, data: Uint8Array): Pr
 export declare function pbkdf2DeriveAesCtrKey(password: Uint8Array, salt: Uint8Array, iterations: number): Promise<CryptoKey>;
 export declare function aesCtrEncrypt(key: CryptoKey, counter: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
 export declare function aesCtrDecrypt(key: CryptoKey, counter: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
-export declare function ed25519VerifyRaw(publicKey: Uint8Array, signature: Uint8Array, message: Uint8Array): Promise<boolean>;

package/dist/types/crypto/core/random.d.ts

@@ -1,8 +1,3 @@
-/**
- * Generates cryptographically secure random bytes
- */
 export declare function randomBytesAsync(size: number): Promise<Uint8Array>;
-/**
- * Generates a cryptographically secure random integer in the range [min, max)
- */
-export declare function randomIntAsync(min: number, max: number): Promise<number>;
+export declare function randomFillAsync(target: Uint8Array, offset?: number, size?: number): Promise<Uint8Array>;
+export declare const randomIntAsync: (min: number, max: number) => Promise<number>;

package/dist/types/crypto/index.d.ts

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

package/dist/types/crypto/math/constants.d.ts

@@ -1,7 +1,9 @@
+import { type Fe } from '../math/fe';
 import type { ExtendedPoint } from '../math/types';
 export declare const FIELD_P: bigint;
 export declare const GROUP_L: bigint;
-export declare const EDWARDS_D: bigint;
-export declare const TWO_D: bigint;
+export declare const FE_TWO_D: Fe;
+export declare const FE_ZERO: Fe;
+export declare const FE_ONE: Fe;
 export declare const BASE_POINT: ExtendedPoint;
 export declare const IDENTITY_POINT: ExtendedPoint;

package/dist/types/crypto/math/fe.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Field element arithmetic for GF(2^255-19).
+ * Representation: 16 limbs of 16 bits in Float64Array (tweetnacl style).
+ * Hot-path operations are allocation-free using pre-allocated temporaries.
+ */
+export type Fe = Float64Array;
+export declare function fe(): Fe;
+export declare function feCopy(o: Fe, a: Fe): void;
+export declare function feFromBigInt(n: bigint): Fe;
+export declare function feToBigInt(a: Fe): bigint;
+export declare function feFromBytes(o: Fe, s: Uint8Array): void;
+export declare function fePack(o: Uint8Array, n: Fe): void;
+export declare function feAdd(o: Fe, a: Fe, b: Fe): void;
+export declare function feSub(o: Fe, a: Fe, b: Fe): void;
+export declare function feNeg(o: Fe, a: Fe): void;
+/**
+ * Fully unrolled field multiplication with folded reduction.
+ * Computes o = a * b mod (2^255-19) using negacyclic convolution:
+ * t[i] = Σ a[j]*b[i-j] (direct) + 38 * Σ a[j]*b[i+16-j] (wrapped)
+ * All values in local variables for register allocation.
+ */
+export declare function feMul(o: Fe, a: Fe, b: Fe): void;
+/**
+ * Fully unrolled field squaring with folded reduction and symmetry.
+ * Exploits a[j]*a[k] == a[k]*a[j] to halve off-diagonal multiplications.
+ * Combined with negacyclic reduction: wrapped terms use a38[k] = 38*a[k].
+ */
+export declare function feSqr(o: Fe, a: Fe): void;
+export declare function feSqrN(o: Fe, a: Fe, n: number): void;
+export declare function feInv(o: Fe, a: Fe): void;

package/dist/types/crypto/math/mod.d.ts

@@ -1,5 +1,3 @@
-import { FIELD_P, GROUP_L } from '../math/constants';
-export { FIELD_P, GROUP_L };
 export declare function mod(value: bigint, modulus?: bigint): bigint;
 export declare function modGroup(value: bigint): bigint;
 export declare function modInv(value: bigint, modulus?: bigint): bigint;

package/dist/types/crypto/math/types.d.ts

@@ -1,6 +1,13 @@
+import type { Fe } from '../math/fe';
 export interface ExtendedPoint {
-    readonly x: bigint;
-    readonly y: bigint;
-    readonly z: bigint;
-    readonly t: bigint;
+    readonly x: Fe;
+    readonly y: Fe;
+    readonly z: Fe;
+    readonly t: Fe;
+}
+export interface MutablePoint {
+    x: Fe;
+    y: Fe;
+    z: Fe;
+    t: Fe;
 }