zapo-js 0.1.2 → 0.2.0

package/dist/types/protocol/jid.d.ts

@@ -4,13 +4,30 @@ export declare function splitJid(jid: string): {
     readonly server: string;
 };
 export declare function normalizeRecipientJid(to: string): string;
-export declare function isJidType(jid: string, type: string): boolean;
 export declare function isGroupJid(jid: string): boolean;
 export declare function isBroadcastJid(jid: string): boolean;
 export declare function isGroupOrBroadcastJid(jid: string): boolean;
+export interface ParsedJid {
+    readonly address: SignalAddress;
+    readonly userJid: string;
+    readonly normalizedJid: string;
+}
 export declare function parseSignalAddressFromJid(jid: string): SignalAddress;
-export declare function toUserJid(jid: string): string;
+export declare function parseJidFull(jid: string): ParsedJid;
+export declare function canonicalizeSignalServer(server: string, hostDomain?: string): string;
+export declare function canonicalizeSignalJid(jid: string, hostDomain?: string): string;
+export declare function toUserJid(jid: string, options?: {
+    readonly canonicalizeSignalServer?: boolean;
+    readonly hostDomain?: string;
+}): string;
 export declare function normalizeDeviceJid(jid: string): string;
+export declare function isHostedDeviceId(deviceId: number): boolean;
+export declare function isHostedServer(server: string): boolean;
+export declare function isHostedDeviceJid(jid: string): boolean;
+export declare function buildDeviceJid(user: string, normalizedServer: string, deviceId: number, options?: {
+    readonly rawServer?: string;
+    readonly isHosted?: boolean;
+}): string;
 export declare function getLoginIdentity(meJid: string): {
     readonly username: number;
     readonly device: number;

package/dist/types/protocol/message.d.ts

@@ -11,6 +11,66 @@ export declare const WA_MESSAGE_TYPES: Readonly<{
     readonly ACK_TYPE_ERROR: "error";
     readonly ACK_CLASS_ERROR: "error";
     readonly ACK_CLASS_MESSAGE: "message";
+    readonly RECEIPT_TYPE_DELIVERY: "delivery";
+    readonly RECEIPT_TYPE_SENDER: "sender";
+    readonly RECEIPT_TYPE_INACTIVE: "inactive";
+    readonly RECEIPT_TYPE_READ: "read";
+    readonly RECEIPT_TYPE_READ_SELF: "read-self";
+    readonly RECEIPT_TYPE_PLAYED: "played";
+    readonly RECEIPT_TYPE_PLAYED_SELF: "played-self";
+    readonly RECEIPT_TYPE_HISTORY_SYNC: "hist_sync";
     readonly RECEIPT_TYPE_PEER: "peer_msg";
+    readonly RECEIPT_TYPE_SERVER_ERROR: "server-error";
+    readonly RECEIPT_TYPE_RETRY: "retry";
 }>;
 export declare const WA_RETRYABLE_ACK_CODES: readonly ["408", "429", "500", "503"];
+export declare const WA_STANZA_MSG_TYPES: Readonly<{
+    readonly TEXT: "text";
+    readonly MEDIA: "media";
+    readonly MEDIA_NOTIFY: "medianotify";
+    readonly PAY: "pay";
+    readonly POLL: "poll";
+    readonly REACTION: "reaction";
+    readonly EVENT: "event";
+}>;
+export declare const WA_EDIT_ATTRS: Readonly<{
+    readonly MESSAGE_EDIT: "1";
+    readonly PIN_IN_CHAT: "2";
+    readonly SENDER_REVOKE: "7";
+    readonly ADMIN_REVOKE: "8";
+}>;
+export declare const WA_POLL_META_TYPES: Readonly<{
+    readonly CREATION: "creation";
+    readonly VOTE: "vote";
+    readonly RESULT_SNAPSHOT: "result_snapshot";
+    readonly EDIT: "edit";
+}>;
+export declare const WA_EVENT_META_TYPES: Readonly<{
+    readonly CREATION: "creation";
+    readonly RESPONSE: "response";
+    readonly EDIT: "edit";
+}>;
+export declare const WA_ENC_MEDIA_TYPES: Readonly<{
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+    readonly PTV: "ptv";
+    readonly AUDIO: "audio";
+    readonly PTT: "ptt";
+    readonly LOCATION: "location";
+    readonly LIVE_LOCATION: "livelocation";
+    readonly VCARD: "vcard";
+    readonly CONTACT_ARRAY: "contact_array";
+    readonly DOCUMENT: "document";
+    readonly URL: "url";
+    readonly GIF: "gif";
+    readonly STICKER: "sticker";
+    readonly STICKER_PACK: "sticker_pack";
+    readonly LIST: "list";
+    readonly LIST_RESPONSE: "list_response";
+    readonly BUTTON: "button";
+    readonly BUTTON_RESPONSE: "buttons_response";
+    readonly ORDER: "order";
+    readonly PRODUCT: "product";
+    readonly NATIVE_FLOW_RESPONSE: "native_flow_response";
+    readonly GROUP_HISTORY: "group_history";
+}>;

package/dist/types/protocol/nodes.d.ts

@@ -78,6 +78,8 @@ export declare const WA_XMLNS: Readonly<{
     readonly PRIVACY: "privacy";
     readonly BLOCKLIST: "blocklist";
     readonly USYNC: "usync";
+    readonly BUSINESS: "w:biz";
+    readonly STATUS: "status";
     readonly GROUPS: "w:g2";
     readonly NEWSLETTER: "newsletter";
     readonly XMPP_PING: "urn:xmpp:ping";

package/dist/types/protocol/notification.d.ts

@@ -1,5 +1,7 @@
 export declare const WA_NOTIFICATION_TYPES: Readonly<{
     readonly GROUP: "w:gp2";
+    readonly ENCRYPT: "encrypt";
+    readonly DEVICES: "devices";
 }>;
 export declare const WA_GROUP_NOTIFICATION_TAGS: Readonly<{
     readonly REMOVE: "remove";

package/dist/types/protocol/privacy-token.d.ts

@@ -0,0 +1,17 @@
+export declare const WA_PRIVACY_TOKEN_TYPES: Readonly<{
+    readonly TRUSTED_CONTACT: "trusted_contact";
+}>;
+export declare const WA_PRIVACY_TOKEN_TAGS: Readonly<{
+    readonly TOKENS: "tokens";
+    readonly TOKEN: "token";
+    readonly TC_TOKEN: "tctoken";
+    readonly CS_TOKEN: "cstoken";
+}>;
+export declare const WA_PRIVACY_TOKEN_NOTIFICATION_TYPE = "privacy_token";
+export declare const WA_TC_TOKEN_DEFAULTS: Readonly<{
+    readonly DURATION_S: 604800;
+    readonly NUM_BUCKETS: 4;
+    readonly SENDER_DURATION_S: 604800;
+    readonly SENDER_NUM_BUCKETS: 4;
+    readonly MAX_DURATION_S: 15552000;
+}>;

package/dist/types/protocol/privacy.d.ts

@@ -0,0 +1,75 @@
+export declare const WA_PRIVACY_CATEGORIES: Readonly<{
+    readonly READ_RECEIPTS: "readreceipts";
+    readonly LAST_SEEN: "last";
+    readonly ONLINE: "online";
+    readonly PROFILE_PICTURE: "profile";
+    readonly ABOUT: "status";
+    readonly GROUP_ADD: "groupadd";
+    readonly CALL_ADD: "calladd";
+    readonly MESSAGES: "messages";
+    readonly DEFENSE_MODE: "defense";
+}>;
+export type WaPrivacyCategory = (typeof WA_PRIVACY_CATEGORIES)[keyof typeof WA_PRIVACY_CATEGORIES];
+export declare const WA_PRIVACY_VALUES: Readonly<{
+    readonly ALL: "all";
+    readonly CONTACTS: "contacts";
+    readonly CONTACT_BLACKLIST: "contact_blacklist";
+    readonly NONE: "none";
+    readonly MATCH_LAST_SEEN: "match_last_seen";
+    readonly KNOWN: "known";
+    readonly OFF: "off";
+    readonly ON_STANDARD: "on_standard";
+    readonly ERROR: "error";
+}>;
+export type WaPrivacyValue = (typeof WA_PRIVACY_VALUES)[keyof typeof WA_PRIVACY_VALUES];
+export declare const WA_PRIVACY_CATEGORY_TO_SETTING: Readonly<{
+    readonly readreceipts: "readReceipts";
+    readonly last: "lastSeen";
+    readonly online: "online";
+    readonly profile: "profilePicture";
+    readonly status: "about";
+    readonly groupadd: "groupAdd";
+    readonly calladd: "callAdd";
+    readonly messages: "messages";
+    readonly defense: "defenseMode";
+}>;
+export declare const WA_PRIVACY_SETTING_TO_CATEGORY: Readonly<{
+    readonly readReceipts: "readreceipts";
+    readonly lastSeen: "last";
+    readonly online: "online";
+    readonly profilePicture: "profile";
+    readonly about: "status";
+    readonly groupAdd: "groupadd";
+    readonly callAdd: "calladd";
+    readonly messages: "messages";
+    readonly defenseMode: "defense";
+}>;
+export type WaPrivacySettingName = keyof typeof WA_PRIVACY_SETTING_TO_CATEGORY;
+export type WaPrivacyVisibility = 'all' | 'contacts' | 'contact_blacklist' | 'none';
+export interface WaPrivacySettingValueMap {
+    readonly readReceipts: 'all' | 'none';
+    readonly lastSeen: WaPrivacyVisibility;
+    readonly online: 'all' | 'none' | 'match_last_seen';
+    readonly profilePicture: WaPrivacyVisibility;
+    readonly about: WaPrivacyVisibility;
+    readonly groupAdd: 'all' | 'contacts' | 'contact_blacklist';
+    readonly callAdd: 'all' | 'known' | 'contacts';
+    readonly messages: 'all' | 'contacts';
+    readonly defenseMode: 'off' | 'on_standard';
+}
+export declare const WA_PRIVACY_DISALLOWED_LIST_CATEGORIES: Readonly<{
+    readonly ABOUT: "status";
+    readonly GROUP_ADD: "groupadd";
+    readonly LAST_SEEN: "last";
+    readonly PROFILE_PICTURE: "profile";
+}>;
+type DisallowedCategoryToSetting = {
+    readonly [K in keyof typeof WA_PRIVACY_DISALLOWED_LIST_CATEGORIES]: (typeof WA_PRIVACY_CATEGORY_TO_SETTING)[(typeof WA_PRIVACY_DISALLOWED_LIST_CATEGORIES)[K]];
+};
+export type WaPrivacyDisallowedListSettingName = DisallowedCategoryToSetting[keyof DisallowedCategoryToSetting];
+export declare const WA_PRIVACY_TAGS: Readonly<{
+    readonly CATEGORY: "category";
+    readonly LIST: "list";
+    readonly USER: "user";
+}>;
+export {};

package/dist/types/protocol/stream.d.ts

@@ -49,6 +49,18 @@ export declare const WA_STREAM_SIGNALING: Readonly<{
     readonly FORCE_LOGIN_CODE: 515;
     readonly FORCE_LOGOUT_CODE: 516;
 }>;
+export declare const WA_FAILURE_REASONS: Readonly<{
+    readonly GENERIC_FAILURE: 400;
+    readonly NOT_AUTHORIZED: 401;
+    readonly TEMP_BANNED: 402;
+    readonly LOCKED: 403;
+    readonly CLIENT_TOO_OLD: 405;
+    readonly BANNED: 406;
+    readonly BAD_USER_AGENT: 409;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly EXPERIMENTAL: 501;
+    readonly SERVICE_UNAVAILABLE: 503;
+}>;
 export declare const WA_DISCONNECT_REASONS: Readonly<{
     readonly CLIENT_DISCONNECTED: "client_disconnected";
     readonly COMMS_STOPPED: "comms_stopped";
@@ -57,4 +69,22 @@ export declare const WA_DISCONNECT_REASONS: Readonly<{
     readonly STREAM_ERROR_ACK: "stream_error_ack";
     readonly STREAM_ERROR_XML_NOT_WELL_FORMED: "stream_error_xml_not_well_formed";
     readonly STREAM_ERROR_OTHER: "stream_error_other";
+    readonly STREAM_ERROR_FORCE_LOGIN: "stream_error_force_login";
+    readonly STREAM_ERROR_FORCE_LOGOUT: "stream_error_force_logout";
+    readonly FAILURE_LOCKED: "failure_locked";
+    readonly FAILURE_NOT_AUTHORIZED: "failure_not_authorized";
+    readonly FAILURE_BANNED: "failure_banned";
+    readonly FAILURE_CLIENT_TOO_OLD: "failure_client_too_old";
+    readonly FAILURE_BAD_USER_AGENT: "failure_bad_user_agent";
+    readonly FAILURE_SERVICE_UNAVAILABLE: "failure_service_unavailable";
+    readonly PRIMARY_IDENTITY_KEY_CHANGE: "primary_identity_key_change";
+}>;
+export declare const WA_CONNECTION_REASONS: Readonly<{
+    readonly CONNECTED: "connected";
+    readonly RECONNECTED: "reconnected";
 }>;
+export type WaFailureReasonCode = (typeof WA_FAILURE_REASONS)[keyof typeof WA_FAILURE_REASONS];
+export type WaStreamErrorCode = typeof WA_STREAM_SIGNALING.FORCE_LOGIN_CODE | typeof WA_STREAM_SIGNALING.FORCE_LOGOUT_CODE;
+export type WaConnectionCode = WaFailureReasonCode | WaStreamErrorCode;
+export type WaDisconnectReason = (typeof WA_DISCONNECT_REASONS)[keyof typeof WA_DISCONNECT_REASONS];
+export type WaConnectionOpenReason = (typeof WA_CONNECTION_REASONS)[keyof typeof WA_CONNECTION_REASONS];

package/dist/types/retry/codec.d.ts

@@ -0,0 +1,3 @@
+import type { WaRetryReplayPayload } from './types';
+export declare function encodeRetryReplayPayload(payload: WaRetryReplayPayload): Uint8Array;
+export declare function decodeRetryReplayPayload(raw: Uint8Array): WaRetryReplayPayload;

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

@@ -1,8 +1,8 @@
 export { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON, RETRY_RECEIPT_VERSION } from './constants';
 export type { WaRetryReasonCode } from './constants';
 export { mapRetryReasonFromError } from './reason';
-export { parseRetryReceiptRequest } from './parse';
-export type { WaParsedRetryRequest, WaRetryDecryptFailureContext, WaRetryEncryptedReplayPayload, WaRetryKey, WaRetryKeyBundle, WaRetryOpaqueNodeReplayPayload, WaRetryOutboundMessageRecord, WaRetryOutboundMode, WaRetryOutboundState, WaRetryPlaintextReplayPayload, WaRetryReceiptType, WaRetryReplayPayload, WaRetrySignedKey } from './types';
-export { decodeRetryReplayPayload, encodeRetryReplayPayload, pickRetryStateMax } from './outbound';
+export { parseRetryReceiptRequest, pickRetryStateMax } from './parse';
+export type { WaParsedRetryRequest, WaRetryDecryptFailureContext, WaRetryEncryptedReplayPayload, WaRetryKey, WaRetryKeyBundle, WaRetryOpaqueNodeReplayPayload, WaRetryOutboundMessageRecord, WaRetryOutboundMode, WaRetryOutboundState, WaRetryPlaintextReplayPayload, WaRetryReceiptType, WaRetryReplayPayload, WaRetryStoredReplayPayload, WaRetrySignedKey } from './types';
+export { decodeRetryReplayPayload, encodeRetryReplayPayload } from './codec';
 export { WaRetryReplayService, type WaRetryReplayServiceOptions, type WaRetryResendResult } from './replay';
 export { createOutboundRetryTracker, type OutboundRetryTrackHint, type OutboundRetryTracker } from './tracker';

package/dist/types/retry/parse.d.ts

@@ -1,3 +1,6 @@
-import type { WaParsedRetryRequest } from './types';
+import type { WaParsedRetryRequest, WaRetryOutboundState } from './types';
 import type { BinaryNode } from '../transport/types';
-export declare function parseRetryReceiptRequest(node: BinaryNode): WaParsedRetryRequest | null;
+export declare function parseRetryReceiptRequest(node: BinaryNode, options?: {
+    readonly expectedToJids?: readonly string[];
+}): WaParsedRetryRequest | null;
+export declare function pickRetryStateMax(left: WaRetryOutboundState, right: WaRetryOutboundState): WaRetryOutboundState;

package/dist/types/retry/tracker.d.ts

@@ -9,6 +9,7 @@ export type OutboundRetryTrackHint = {
     readonly replayPayload: WaRetryReplayPayload;
     readonly participantJid?: string;
     readonly recipientJid?: string;
+    readonly eligibleRequesterDeviceJids?: readonly string[];
 };
 export type OutboundRetryTracker = {
     track(hint: OutboundRetryTrackHint, publish: () => Promise<WaMessagePublishResult>): Promise<WaMessagePublishResult>;

package/dist/types/retry/types.d.ts

@@ -22,6 +22,8 @@ export interface WaParsedRetryRequest {
     readonly from: string;
     readonly participant?: string;
     readonly recipient?: string;
+    readonly offline: boolean;
+    readonly isLid: boolean;
     readonly originalMsgId: string;
     readonly retryCount: number;
     readonly retryReason?: number;
@@ -56,14 +58,17 @@ export interface WaRetryOpaqueNodeReplayPayload {
     readonly node: Uint8Array;
 }
 export type WaRetryReplayPayload = WaRetryPlaintextReplayPayload | WaRetryEncryptedReplayPayload | WaRetryOpaqueNodeReplayPayload;
+export type WaRetryStoredReplayPayload = Uint8Array | WaRetryReplayPayload;
 export interface WaRetryOutboundMessageRecord {
     readonly messageId: string;
     readonly toJid: string;
     readonly participantJid?: string;
     readonly recipientJid?: string;
+    readonly eligibleRequesterDeviceJids?: readonly string[];
+    readonly deliveredRequesterDeviceJids?: readonly string[];
     readonly messageType: string;
     readonly replayMode: WaRetryOutboundMode;
-    readonly replayPayload: Uint8Array;
+    readonly replayPayload: WaRetryStoredReplayPayload;
     readonly state: WaRetryOutboundState;
     readonly createdAtMs: number;
     readonly updatedAtMs: number;

package/dist/types/signal/api/SignalDeviceSyncApi.d.ts

@@ -22,11 +22,13 @@ export declare class SignalDeviceSyncApi {
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
     private readonly generateSid;
+    private readonly syncDedup;
     constructor(options: SignalDeviceSyncApiOptions);
     syncDeviceList(userJids: readonly string[], timeoutMs?: number): Promise<readonly {
         readonly jid: string;
         readonly deviceJids: readonly string[];
     }[]>;
+    private syncDeviceListInternal;
     queryLidsByPhoneJids(phoneJids: readonly string[], timeoutMs?: number): Promise<readonly SignalLidSyncResult[]>;
     private collectUsersToQuery;
     private makeDeviceSyncRequest;
@@ -38,6 +40,5 @@ export declare class SignalDeviceSyncApi {
     private parseUserDeviceJids;
     private normalizeUsers;
     private normalizeUserJid;
-    private toDeviceJid;
 }
 export {};

package/dist/types/signal/api/SignalDigestSyncApi.d.ts

@@ -1,4 +1,5 @@
 import type { Logger } from '../../infra/log/types';
+import type { RegistrationInfo, SignedPreKeyRecord } from '../types';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface SignalDigestSyncApiOptions {
@@ -14,6 +15,10 @@ export interface SignalDigestValidationResult {
     readonly reason: 'ok' | 'missing_remote_digest' | 'unsupported_key_bundle_type' | 'missing_local_state' | 'registration_mismatch' | 'identity_mismatch' | 'signed_prekey_mismatch' | 'missing_local_prekey' | 'hash_mismatch';
     readonly preKeyCount: number;
 }
+export interface SignalDigestPrefetchedLocalKeyBundle {
+    readonly registrationInfo: RegistrationInfo;
+    readonly signedPreKey: SignedPreKeyRecord;
+}
 export declare class SignalDigestSyncApi {
     private readonly logger;
     private readonly query;
@@ -22,6 +27,7 @@ export declare class SignalDigestSyncApi {
     private readonly hostDomain;
     constructor(options: SignalDigestSyncApiOptions);
     validateLocalKeyBundle(timeoutMs?: number): Promise<SignalDigestValidationResult>;
+    validateLocalKeyBundle(prefetched?: SignalDigestPrefetchedLocalKeyBundle, timeoutMs?: number): Promise<SignalDigestValidationResult>;
     private parseDigestPayload;
 }
 export {};

package/dist/types/signal/api/SignalIdentitySyncApi.d.ts

@@ -19,8 +19,10 @@ export declare class SignalIdentitySyncApi {
     private readonly signalStore?;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
+    private readonly syncDedup;
     constructor(options: SignalIdentitySyncApiOptions);
     syncIdentityKeys(targetJids: readonly string[], timeoutMs?: number): Promise<readonly SignalIdentitySyncEntry[]>;
+    private syncIdentityKeysInternal;
     private parseIdentitySyncResponse;
 }
 export {};

package/dist/types/signal/api/SignalRotateKeyApi.d.ts

@@ -7,16 +7,15 @@ interface SignalRotateKeyApiOptions {
     readonly signalStore: WaSignalStore;
     readonly defaultTimeoutMs?: number;
 }
-export interface SignalRotateKeyResult {
-    readonly shouldDigestKey: boolean;
-    readonly errorCode?: number;
-}
 export declare class SignalRotateKeyApi {
     private readonly logger;
     private readonly query;
     private readonly signalStore;
     private readonly defaultTimeoutMs;
     constructor(options: SignalRotateKeyApiOptions);
-    rotateSignedPreKey(timeoutMs?: number): Promise<SignalRotateKeyResult>;
+    rotateSignedPreKey(timeoutMs?: number): Promise<{
+        shouldDigestKey: boolean;
+        errorCode?: number;
+    }>;
 }
 export {};

package/dist/types/signal/api/SignalSessionSyncApi.d.ts

@@ -7,10 +7,6 @@ interface SignalSessionSyncApiOptions {
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
 }
-interface SignalSessionSyncTarget {
-    readonly jid: string;
-    readonly reasonIdentity?: boolean;
-}
 export type SignalSessionKeyBundleResult = {
     readonly jid: string;
     readonly bundle: SignalPreKeyBundle;
@@ -26,12 +22,18 @@ export declare class SignalSessionSyncApi {
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
     constructor(options: SignalSessionSyncApiOptions);
-    fetchKeyBundle(target: SignalSessionSyncTarget, timeoutMs?: number): Promise<{
+    fetchKeyBundle(target: {
+        readonly jid: string;
+        readonly reasonIdentity?: boolean;
+    }, timeoutMs?: number): Promise<{
         readonly jid: string;
         readonly bundle: SignalPreKeyBundle;
         readonly deviceIdentity?: Uint8Array;
     }>;
-    fetchKeyBundles(targets: readonly SignalSessionSyncTarget[], timeoutMs?: number): Promise<readonly SignalSessionKeyBundleResult[]>;
+    fetchKeyBundles(targets: readonly {
+        readonly jid: string;
+        readonly reasonIdentity?: boolean;
+    }[], timeoutMs?: number): Promise<readonly SignalSessionKeyBundleResult[]>;
     private parseFetchKeyBundleResponse;
     private parseUserKeyBundle;
 }

package/dist/types/signal/api/result-map.d.ts

@@ -0,0 +1 @@
+export declare function registerParsedResultByRawAndCanonicalKey<T>(parsedByRawKey: Map<string, T>, parsedByCanonicalKey: Map<string, T>, rawKey: string, canonicalKey: string, result: T, isPreferred: (value: T) => boolean): void;

package/dist/types/signal/constants.d.ts

@@ -1,9 +1,6 @@
 export declare const SIGNAL_VERSION = 3;
 export declare const SIGNAL_GROUP_VERSION = 3;
-export declare const SERIALIZED_PUB_KEY_PREFIX = 5;
-export declare const KEY_TYPE_CURVE25519 = 5;
 export declare const SIGNAL_MAC_SIZE = 8;
-export declare const SIGNATURE_SIZE = 64;
 export declare const MAX_PREV_SESSIONS = 40;
 export declare const MAX_UNUSED_KEYS = 2000;
 export declare const FUTURE_MESSAGES_MAX = 2000;

package/dist/types/signal/{store/sqlite.d.ts → encoding.d.ts}

@@ -1,4 +1,4 @@
-import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../types';
+import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from './types';
 export interface SignalAddressParts {
     readonly user: string;
     readonly server: string;
@@ -51,7 +51,7 @@ export interface SenderKeyDistributionRow extends Record<string, unknown> {
     readonly key_id: unknown;
     readonly timestamp_ms: unknown;
 }
-export interface SqliteCountRow extends Record<string, unknown> {
+export interface StoreCountRow extends Record<string, unknown> {
     readonly count: unknown;
 }
 export declare function toSignalAddressParts(address: SignalAddress): SignalAddressParts;
@@ -68,5 +68,5 @@ export declare function decodeSignalSessionRecord(raw: unknown): SignalSessionRe
 export declare function encodeSenderKeyRecord(record: SenderKeyRecord): Uint8Array;
 export declare function decodeSenderKeyRecord(raw: unknown, groupId: string, sender: SignalAddress): SenderKeyRecord;
 export declare function decodeSenderKeyDistributionRow(row: SenderKeyDistributionRow): SenderKeyDistributionRecord;
-export declare function decodeSqliteCount(row: SqliteCountRow | null, field: string): number;
+export declare function decodeStoreCount(row: StoreCountRow | null, field: string): number;
 export declare function decodeSignalRemoteIdentity(raw: unknown): Uint8Array;

package/dist/types/signal/group/SenderKeyManager.d.ts

@@ -10,13 +10,18 @@ interface GroupSenderKeyCiphertext {
 }
 export declare class SenderKeyManager {
     private readonly store;
+    private readonly senderLock;
     constructor(store: WaSenderKeyStore);
-    createSenderKeyDistributionMessage(groupId: string, sender: SignalAddress): Promise<Proto.Message.ISenderKeyDistributionMessage>;
-    filterParticipantsNeedingDistribution(groupId: string, sender: SignalAddress, participants: readonly SignalAddress[]): Promise<readonly SignalAddress[]>;
-    markSenderKeyDistributed(groupId: string, sender: SignalAddress, participants: readonly SignalAddress[]): Promise<void>;
+    prepareGroupEncryption(groupId: string, sender: SignalAddress, plaintext: Uint8Array): Promise<{
+        readonly distributionMessage: Proto.Message.ISenderKeyDistributionMessage;
+        readonly ciphertext: GroupSenderKeyCiphertext;
+        readonly keyId: number;
+    }>;
+    filterParticipantsNeedingDistribution(groupId: string, senderKeyId: number, participants: readonly SignalAddress[]): Promise<readonly SignalAddress[]>;
+    markSenderKeyDistributed(groupId: string, senderKeyId: number, participants: readonly SignalAddress[]): Promise<void>;
     processSenderKeyDistributionPayload(groupId: string, sender: SignalAddress, payload: Uint8Array): Promise<SenderKeyRecord>;
-    encryptGroupMessage(groupId: string, sender: SignalAddress, plaintext: Uint8Array): Promise<GroupSenderKeyCiphertext>;
     decryptGroupMessage(payload: GroupSenderKeyCiphertext): Promise<Uint8Array>;
-    private ensureSenderKey;
+    private ensureSenderKeyInternal;
+    private runWithSenderLock;
 }
 export {};

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

@@ -1,4 +1,6 @@
 export { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalPreKeyBundle, SignedPreKeyRecord } from './types';
+export type { SignalSessionRecord } from './types';
+export { decodeSignalPreKeyRow, decodeSignalRegistrationRow, decodeSignalRemoteIdentity, decodeSignalSessionRecord, decodeSignalSignedPreKeyRow, decodeSenderKeyDistributionRow, decodeSenderKeyRecord, decodeStoreCount, encodeSenderKeyRecord, encodeSignalSessionRecord, toSignalAddressParts, type SenderKeyDistributionRow, type SenderKeyRow, type SignalAddressParts, type SignalIdentityRow, type SignalMetaRow, type SignalPreKeyRow, type SignalRegistrationRow, type SignalSessionRow, type SignalSignedPreKeyRow, type StoreCountRow } from './encoding';
 export { generatePreKeyPair, generateRegistrationId, generateRegistrationInfo, generateSignedPreKey } from './registration/keygen';
 export { buildPreKeyUploadIq, parsePreKeyUploadFailure } from './api/prekeys';
 export { SignalDigestSyncApi } from './api/SignalDigestSyncApi';

package/dist/types/signal/session/SignalProtocol.d.ts

@@ -1,13 +1,15 @@
 import type { Logger } from '../../infra/log/types';
 import type { SignalAddress, SignalPreKeyBundle, SignalSessionRecord } from '../types';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
+interface EstablishOutgoingSessionOptions {
+    readonly reuseExisting?: boolean;
+}
 export declare class SignalProtocol {
     private readonly store;
     private readonly logger;
+    private readonly sessionMutationLock;
     constructor(store: WaSignalStore, logger?: Logger);
-    hasSession(address: SignalAddress): Promise<boolean>;
-    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
-    establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle): Promise<SignalSessionRecord>;
+    establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle, options?: EstablishOutgoingSessionOptions): Promise<SignalSessionRecord>;
     encryptMessage(address: SignalAddress, plaintext: Uint8Array, expectedIdentity?: Uint8Array): Promise<{
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
@@ -17,6 +19,9 @@ export declare class SignalProtocol {
         readonly address: SignalAddress;
         readonly plaintext: Uint8Array;
         readonly expectedIdentity?: Uint8Array;
+    }[], prefetchedSessions?: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
     }[]): Promise<readonly {
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
@@ -26,6 +31,7 @@ export declare class SignalProtocol {
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;
     }): Promise<Uint8Array>;
-    private decryptMsgInternal;
+    private runWithAddressLock;
     private decryptPkMsg;
 }
+export {};

package/dist/types/signal/session/resolver.d.ts

@@ -2,11 +2,16 @@ import type { Logger } from '../../infra/log/types';
 import type { SignalIdentitySyncApi } from '../api/SignalIdentitySyncApi';
 import type { SignalSessionSyncApi } from '../api/SignalSessionSyncApi';
 import type { SignalProtocol } from '../session/SignalProtocol';
-import type { SignalAddress } from '../types';
+import type { SignalAddress, SignalSessionRecord } from '../types';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
+export interface SignalResolvedSessionTarget {
+    readonly jid: string;
+    readonly address: SignalAddress;
+    readonly session: SignalSessionRecord;
+}
 export type SignalSessionResolver = {
     ensureSession(address: SignalAddress, jid: string, expectedIdentity?: Uint8Array, reasonIdentity?: boolean): Promise<void>;
-    ensureSessionsBatch(targetJids: readonly string[], expectedIdentityByJid?: ReadonlyMap<string, Uint8Array>): Promise<void>;
+    ensureSessionsBatch(targetJids: readonly string[], expectedIdentityByJid?: ReadonlyMap<string, Uint8Array>): Promise<readonly SignalResolvedSessionTarget[]>;
 };
 export declare function createSignalSessionResolver(options: {
     readonly signalProtocol: SignalProtocol;

package/dist/types/store/contracts/appstate.store.d.ts

@@ -14,7 +14,7 @@ export interface WaAppStateCollectionStateUpdate {
 export interface WaAppStateStore {
     exportData(): Promise<WaAppStateStoreData>;
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
-    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeysBatch(keyIds: readonly Uint8Array[]): Promise<readonly (WaAppStateSyncKey | null)[]>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
     getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;

package/dist/types/store/contracts/privacy-token.store.d.ts

@@ -0,0 +1,16 @@
+export interface WaStoredPrivacyTokenRecord {
+    readonly jid: string;
+    readonly tcToken?: Uint8Array;
+    readonly tcTokenTimestamp?: number;
+    readonly tcTokenSenderTimestamp?: number;
+    readonly nctSalt?: Uint8Array;
+    readonly updatedAtMs: number;
+}
+export interface WaPrivacyTokenStore {
+    upsert(record: WaStoredPrivacyTokenRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredPrivacyTokenRecord[]): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredPrivacyTokenRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+    destroy?(): Promise<void>;
+}

package/dist/types/store/contracts/retry.store.d.ts

@@ -1,10 +1,17 @@
 import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../retry/types';
 export interface WaRetryStore {
+    getOutboundRequesterStatus(messageId: string, requesterDeviceJid: string): Promise<{
+        readonly eligible: boolean;
+        readonly delivered: boolean;
+    } | null>;
     getTtlMs?(): number;
+    supportsRawReplayPayload?(): boolean;
     destroy?(): Promise<void>;
     upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    deleteOutboundMessage(messageId: string): Promise<number>;
     getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
     updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    markOutboundRequesterDelivered(messageId: string, requesterDeviceJid: string, updatedAtMs: number, expiresAtMs: number): Promise<void>;
     incrementInboundCounter(messageId: string, requesterJid: string, updatedAtMs: number, expiresAtMs: number): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/contracts/signal.store.d.ts

@@ -1,4 +1,10 @@
 import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../signal/types';
+export interface WaSignalMetaSnapshot {
+    readonly serverHasPreKeys: boolean;
+    readonly signedPreKeyRotationTs: number | null;
+    readonly registrationInfo: RegistrationInfo | null;
+    readonly signedPreKey: SignedPreKeyRecord | null;
+}
 export interface WaSignalStore {
     getRegistrationInfo(): Promise<RegistrationInfo | null>;
     setRegistrationInfo(info: RegistrationInfo): Promise<void>;
@@ -16,6 +22,7 @@ export interface WaSignalStore {
     markKeyAsUploaded(keyId: number): Promise<void>;
     setServerHasPreKeys(value: boolean): Promise<void>;
     getServerHasPreKeys(): Promise<boolean>;
+    getSignalMeta(): Promise<WaSignalMetaSnapshot>;
     hasSession(address: SignalAddress): Promise<boolean>;
     hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
     getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;

package/dist/types/store/createStore.d.ts

@@ -1,2 +1,2 @@
 import type { WaCreateStoreOptions, WaStore } from './types';
-export declare function createStore(options: WaCreateStoreOptions): WaStore;
+export declare function createStore<B extends string>(options: WaCreateStoreOptions<B>): WaStore;