zapo-js 0.2.0 → 0.3.0

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

@@ -21,46 +21,38 @@ export interface WaMessagePublishResult {
     readonly ackNode: BinaryNode;
     readonly ack: WaMessageAckMetadata;
 }
-type MediaInput = Uint8Array | ArrayBuffer | Readable;
+type MediaInput = Uint8Array | ArrayBuffer | Readable | string;
+type MediaFieldsFilledByBuilder = 'url' | 'mimetype' | 'fileSha256' | 'fileLength' | 'mediaKey' | 'fileEncSha256' | 'directPath' | 'mediaKeyTimestamp' | 'streamingSidecar' | 'metadataUrl';
+type UserMediaFields<T> = {
+    readonly [K in keyof Omit<T, MediaFieldsFilledByBuilder>]?: T[K];
+};
 interface WaSendMediaBase {
     readonly media: MediaInput;
     readonly mimetype: string;
     readonly fileLength?: number;
 }
-interface WaSendImageMessage extends WaSendMediaBase {
+interface WaSendMediaBaseOptionalMime {
+    readonly media: MediaInput;
+    readonly mimetype?: string;
+    readonly fileLength?: number;
+}
+interface WaSendImageMessage extends WaSendMediaBase, UserMediaFields<Proto.Message.IImageMessage> {
     readonly type: 'image';
-    readonly caption?: string;
-    readonly width?: number;
-    readonly height?: number;
 }
-interface WaSendVideoMessage extends WaSendMediaBase {
+interface WaSendVideoMessage extends WaSendMediaBase, UserMediaFields<Proto.Message.IVideoMessage> {
     readonly type: 'video';
-    readonly caption?: string;
-    readonly gifPlayback?: boolean;
-    readonly seconds?: number;
-    readonly width?: number;
-    readonly height?: number;
 }
-interface WaSendPtvMessage extends WaSendMediaBase {
+interface WaSendPtvMessage extends WaSendMediaBase, UserMediaFields<Proto.Message.IVideoMessage> {
     readonly type: 'ptv';
-    readonly seconds?: number;
-    readonly width?: number;
-    readonly height?: number;
 }
-interface WaSendAudioMessage extends WaSendMediaBase {
+interface WaSendAudioMessage extends WaSendMediaBase, UserMediaFields<Proto.Message.IAudioMessage> {
     readonly type: 'audio';
-    readonly ptt?: boolean;
-    readonly seconds?: number;
 }
-interface WaSendDocumentMessage extends WaSendMediaBase {
+interface WaSendDocumentMessage extends WaSendMediaBase, UserMediaFields<Proto.Message.IDocumentMessage> {
     readonly type: 'document';
-    readonly caption?: string;
-    readonly fileName?: string;
 }
-interface WaSendStickerMessage extends WaSendMediaBase {
+interface WaSendStickerMessage extends WaSendMediaBaseOptionalMime, UserMediaFields<Proto.Message.IStickerMessage> {
     readonly type: 'sticker';
-    readonly width?: number;
-    readonly height?: number;
 }
 export type WaSendMediaMessage = WaSendImageMessage | WaSendVideoMessage | WaSendPtvMessage | WaSendAudioMessage | WaSendDocumentMessage | WaSendStickerMessage;
 export type WaSendMessageContent = string | Proto.IMessage | WaSendMediaMessage;

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

@@ -0,0 +1,142 @@
+export declare const WA_ABPROPS_PROTOCOL_VERSION = "1";
+export declare const WA_ABPROPS_REFRESH_BOUNDS: Readonly<{
+    readonly MIN_S: 600;
+    readonly MAX_S: 604800;
+    readonly DEFAULT_S: 86400;
+}>;
+export type AbPropType = 'bool' | 'int' | 'string';
+export type AbPropValue = boolean | number | string;
+export interface AbPropConfigEntry {
+    readonly configCode: number;
+    readonly type: AbPropType;
+    readonly defaultValue: AbPropValue;
+}
+export declare const AB_PROP_CONFIGS: Readonly<{
+    readonly syncd_key_max_use_days: AbPropConfigEntry;
+    readonly syncd_wait_for_key_timeout_days: AbPropConfigEntry;
+    readonly syncd_sentinel_timeout_seconds: AbPropConfigEntry;
+    readonly syncd_inline_mutations_max_count: AbPropConfigEntry;
+    readonly syncd_patch_protobuf_max_size: AbPropConfigEntry;
+    readonly syncd_additional_mutations_count: AbPropConfigEntry;
+    readonly syncd_periodic_sync_days: AbPropConfigEntry;
+    readonly syncd_mutation_and_bundle_logging: AbPropConfigEntry;
+    readonly wa_web_enable_syncd_key_persistence_only_after_server_ack: AbPropConfigEntry;
+    readonly web_request_missing_keys_for_removes: AbPropConfigEntry;
+    readonly web_syncd_max_mutations_to_process_during_resume: AbPropConfigEntry;
+    readonly web_syncd_fatal_fields_from_L1104589PRV2: AbPropConfigEntry;
+    readonly web_enable_improved_bulk_merge: AbPropConfigEntry;
+    readonly snapshot_recovery_max_mutations_count_allowed: AbPropConfigEntry;
+    readonly md_syncd_logging_spec_enabled: AbPropConfigEntry;
+    readonly kmp_syncd_engine_crypto_enabled: AbPropConfigEntry;
+    readonly enable_syncd_debug_data_in_patch: AbPropConfigEntry;
+    readonly enable_mention_everyone_syncd_sender: AbPropConfigEntry;
+    readonly username_contact_syncd_support_enable: AbPropConfigEntry;
+    readonly after_read_sending_enabled: AbPropConfigEntry;
+    readonly after_read_fallback_duration: AbPropConfigEntry;
+    readonly after_read_receiver_enabled: AbPropConfigEntry;
+    readonly privacy_token_sending_on_all_1_on_1_messages: AbPropConfigEntry;
+    readonly flows_termination_message_v2_sending_enabled: AbPropConfigEntry;
+    readonly dm_initiator_trigger_groups: AbPropConfigEntry;
+    readonly placeholder_message_resend_maximum_days_limit: AbPropConfigEntry;
+    readonly message_edit_to_message_secret_sender_enabled: AbPropConfigEntry;
+    readonly message_edit_to_message_secret_receiver_enabled: AbPropConfigEntry;
+    readonly top_level_message_secret_check: AbPropConfigEntry;
+    readonly parse_encrypted_dsm_msg_fix: AbPropConfigEntry;
+    readonly rt_sender_dual_encrypted_msg_enabled: AbPropConfigEntry;
+    readonly rt_receiver_dual_encrypted_msg_enabled: AbPropConfigEntry;
+    readonly lid_one_to_one_migration_event_response_force_pn_jid: AbPropConfigEntry;
+    readonly web_anr_async_msg_send_handler: AbPropConfigEntry;
+    readonly message_keys_async_chunk_size: AbPropConfigEntry;
+    readonly synced_message_keys_processing_type: AbPropConfigEntry;
+    readonly limit_sharing_protocol_message_receiver_enabled: AbPropConfigEntry;
+    readonly web_pnless_stanzas: AbPropConfigEntry;
+    readonly wa_nct_token_send_enabled: AbPropConfigEntry;
+    readonly wa_nct_token_syncd_enabled: AbPropConfigEntry;
+    readonly wa_nct_token_history_sync_enabled: AbPropConfigEntry;
+    readonly community_announcement_group_size_limit: AbPropConfigEntry;
+    readonly group_size_limit: AbPropConfigEntry;
+    readonly group_max_subject: AbPropConfigEntry;
+    readonly group_description_length: AbPropConfigEntry;
+    readonly anyone_can_link_to_groups: AbPropConfigEntry;
+    readonly group_call_max_participants: AbPropConfigEntry;
+    readonly group_history_receive: AbPropConfigEntry;
+    readonly group_history_send: AbPropConfigEntry;
+    readonly group_history_settings: AbPropConfigEntry;
+    readonly group_history_settings_query: AbPropConfigEntry;
+    readonly group_history_message_count_limit: AbPropConfigEntry;
+    readonly group_history_message_count_receiver_upper_limit: AbPropConfigEntry;
+    readonly group_history_messages_time_limit_receiver_enforcement_secs: AbPropConfigEntry;
+    readonly group_history_bundle_time_limit_receiver_enforcement_secs: AbPropConfigEntry;
+    readonly group_history_notice_receive: AbPropConfigEntry;
+    readonly group_history_out_of_window_pin_sender: AbPropConfigEntry;
+    readonly group_history_out_of_window_pins_receiver: AbPropConfigEntry;
+    readonly group_history_reporting: AbPropConfigEntry;
+    readonly group_create_add_using_lid_jids: AbPropConfigEntry;
+    readonly group_member_updates_hide_in_thread_enabled: AbPropConfigEntry;
+    readonly group_status_receiver_enabled: AbPropConfigEntry;
+    readonly web_send_invisible_msg_max_group_size: AbPropConfigEntry;
+    readonly web_send_invisible_msg_min_group_size: AbPropConfigEntry;
+    readonly admin_only_mention_everyone_group_size: AbPropConfigEntry;
+    readonly web_abprop_drop_full_history_sync: AbPropConfigEntry;
+    readonly wa_web_history_sync_dynamic_throttling: AbPropConfigEntry;
+    readonly web_e2e_backfill_expire_time: AbPropConfigEntry;
+    readonly history_sync_on_demand: AbPropConfigEntry;
+    readonly history_sync_on_demand_message_count: AbPropConfigEntry;
+    readonly history_sync_on_demand_failure_limit: AbPropConfigEntry;
+    readonly history_sync_on_demand_cooldown_sec: AbPropConfigEntry;
+    readonly history_sync_on_demand_complete_companion: AbPropConfigEntry;
+    readonly history_sync_on_demand_with_android_beta: AbPropConfigEntry;
+    readonly web_anr_throttle_history_sync_db_writes: AbPropConfigEntry;
+    readonly web_force_lid_chats_in_history: AbPropConfigEntry;
+    readonly web_history_sync_allow_duplicate_in_bulk_error: AbPropConfigEntry;
+    readonly default_media_limit_mb: AbPropConfigEntry;
+    readonly web_image_max_edge: AbPropConfigEntry;
+    readonly web_image_max_hd_edge: AbPropConfigEntry;
+    readonly web_channel_video_server_transcode_upload: AbPropConfigEntry;
+    readonly web_deprecate_mms4_hash_based_download: AbPropConfigEntry;
+    readonly kaleidoscope_thumbnail_validation: AbPropConfigEntry;
+    readonly web_use_kaleidoscope_media_check_enabled: AbPropConfigEntry;
+    readonly low_cache_hit_rate_media_types: AbPropConfigEntry;
+    readonly web_anr_async_media_decryption_enabled: AbPropConfigEntry;
+    readonly web_anr_media_chunk_enc_delay_enabled: AbPropConfigEntry;
+    readonly web_media_compute_in_worker_enabled: AbPropConfigEntry;
+    readonly adv_accept_hosted_devices: AbPropConfigEntry;
+    readonly num_days_key_index_list_expiration: AbPropConfigEntry;
+    readonly num_days_before_device_expiry_check: AbPropConfigEntry;
+    readonly web_adv_logout_on_self_device_list_expired: AbPropConfigEntry;
+    readonly md_icdc_hash_length: AbPropConfigEntry;
+    readonly noise_pq_mode: AbPropConfigEntry;
+    readonly tctoken_duration: AbPropConfigEntry;
+    readonly tctoken_num_buckets: AbPropConfigEntry;
+    readonly tctoken_num_buckets_sender: AbPropConfigEntry;
+    readonly tctoken_duration_sender: AbPropConfigEntry;
+    readonly heartbeat_interval_s: AbPropConfigEntry;
+    readonly web_offline_message_processor_timeout_seconds: AbPropConfigEntry;
+    readonly web_offline_resume_wait_for_ping_response_enabled: AbPropConfigEntry;
+    readonly web_offline_resume_wait_for_ping_timeout_seconds: AbPropConfigEntry;
+    readonly web_comms_socket_reconnect_enabled: AbPropConfigEntry;
+    readonly web_resume_optimized_read_receipt_send_interval: AbPropConfigEntry;
+    readonly web_reaction_inactive_receipt: AbPropConfigEntry;
+    readonly lid_status_non_soaked_client_support_enabled: AbPropConfigEntry;
+    readonly s567418_mitigation_enabled: AbPropConfigEntry;
+    readonly web_signal_future_messages_max: AbPropConfigEntry;
+    readonly poll_add_option_enabled: AbPropConfigEntry;
+    readonly poll_add_option_receiving_enabled: AbPropConfigEntry;
+    readonly poll_creator_edit_enabled: AbPropConfigEntry;
+    readonly poll_creator_edit_receiving_version: AbPropConfigEntry;
+    readonly poll_end_time_enabled: AbPropConfigEntry;
+    readonly poll_end_time_receiving_enabled: AbPropConfigEntry;
+    readonly poll_hide_voters_enabled: AbPropConfigEntry;
+    readonly poll_hide_voters_receiving_enabled: AbPropConfigEntry;
+    readonly text_status_ttl_seconds_allowlist: AbPropConfigEntry;
+    readonly username_enabled_on_companion: AbPropConfigEntry;
+    readonly username_max_length: AbPropConfigEntry;
+    readonly username_min_length: AbPropConfigEntry;
+    readonly wa_individual_new_chat_msg_capping_enabled: AbPropConfigEntry;
+    readonly wa_individual_new_chat_msg_capping_limit: AbPropConfigEntry;
+    readonly wa_individual_new_chat_msg_capping_fetch_ttl_seconds: AbPropConfigEntry;
+    readonly enable_web_calling: AbPropConfigEntry;
+    readonly calling_lid_version: AbPropConfigEntry;
+}>;
+export type AbPropName = keyof typeof AB_PROP_CONFIGS;
+export declare function resolveAbPropNameByCode(configCode: number): AbPropName | undefined;

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

@@ -20,3 +20,4 @@ export declare const WA_COMPANION_PLATFORM_IDS: Readonly<{
     readonly OTHER_WEB_CLIENT: "9";
 }>;
 export declare function getWaCompanionPlatformId(browser: string): string;
+export declare function getWaBrowserDisplayName(browser: string): string;

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

@@ -7,10 +7,14 @@ export { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_MESSAGE_TAGS
 export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
 export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media';
 export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty';
-export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification';
+export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES, WA_REGISTRATION_NOTIFICATION_TAGS } from './notification';
 export { WA_PRIVACY_TOKEN_NOTIFICATION_TYPE, WA_PRIVACY_TOKEN_TAGS, WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from './privacy-token';
 export { WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES } from './privacy';
 export type { WaPrivacyCategory, WaPrivacySettingName, WaPrivacyValue } from './privacy';
 export { WA_DEFAULTS } from './defaults';
+export { WA_EMAIL_CONTEXTS, WA_EMAIL_ERROR_CODES, WA_EMAIL_LIMITS, WA_EMAIL_TAGS, WA_EMAIL_XMLNS } from './email';
+export type { WaEmailContext, WaEmailErrorCode } from './email';
+export { AB_PROP_CONFIGS, resolveAbPropNameByCode, WA_ABPROPS_PROTOCOL_VERSION, WA_ABPROPS_REFRESH_BOUNDS } from './abprops';
+export type { AbPropConfigEntry, AbPropName, AbPropType, AbPropValue } from './abprops';
 export { WA_GROUP_PARTICIPANT_TYPES, type WaGroupSetting } from './group';
 export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync';

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

@@ -0,0 +1,32 @@
+export declare const WA_EMAIL_XMLNS = "urn:xmpp:whatsapp:account";
+export declare const WA_EMAIL_TAGS: Readonly<{
+    readonly EMAIL: "email";
+    readonly EMAIL_ADDRESS: "email_address";
+    readonly VERIFY_EMAIL: "verify_email";
+    readonly CONFIRM_EMAIL: "confirm_email";
+    readonly CONTEXT: "context";
+    readonly CODE: "code";
+    readonly LG: "lg";
+    readonly LC: "lc";
+    readonly AUTO_VERIFY: "auto_verify";
+    readonly CONFIRMED: "confirmed";
+}>;
+export declare const WA_EMAIL_CONTEXTS: Readonly<{
+    readonly ONBOARDING: "onboarding";
+    readonly SETTINGS: "settings";
+}>;
+export type WaEmailContext = (typeof WA_EMAIL_CONTEXTS)[keyof typeof WA_EMAIL_CONTEXTS];
+export declare const WA_EMAIL_LIMITS: Readonly<{
+    readonly EMAIL_MAX_LENGTH: 320;
+    readonly CODE_LENGTH: 6;
+    readonly LOCALE_MIN_LENGTH: 2;
+    readonly LOCALE_MAX_LENGTH: 3;
+}>;
+export declare const WA_EMAIL_ERROR_CODES: Readonly<{
+    readonly FORBIDDEN: 403;
+    readonly LOCKOUT: 534;
+    readonly CODE_EXPIRED: 535;
+    readonly CODE_INCORRECT: 536;
+    readonly TOO_MANY_RETRIES: 537;
+}>;
+export type WaEmailErrorCode = (typeof WA_EMAIL_ERROR_CODES)[keyof typeof WA_EMAIL_ERROR_CODES];

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

@@ -4,6 +4,7 @@ export declare function splitJid(jid: string): {
     readonly server: string;
 };
 export declare function normalizeRecipientJid(to: string): string;
+export declare function isLidJid(jid: string): boolean;
 export declare function isGroupJid(jid: string): boolean;
 export declare function isBroadcastJid(jid: string): boolean;
 export declare function isGroupOrBroadcastJid(jid: string): boolean;

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

@@ -32,6 +32,7 @@ export declare const WA_NODE_TAGS: Readonly<{
     readonly DESCRIPTION: "description";
     readonly MY_ADDONS: "my_addons";
     readonly KEY: "key";
+    readonly OP: "op";
     readonly REGISTRATION: "registration";
     readonly TYPE: "type";
     readonly IDENTITY: "identity";
@@ -61,6 +62,7 @@ export declare const WA_NODE_TAGS: Readonly<{
     readonly EPHEMERAL: "ephemeral";
     readonly MEMBERSHIP_APPROVAL_MODE: "membership_approval_mode";
     readonly GROUP_JOIN: "group_join";
+    readonly ABPROPS: "abprops";
 }>;
 export declare const WA_IQ_TYPES: Readonly<{
     readonly GET: "get";
@@ -84,4 +86,6 @@ export declare const WA_XMLNS: Readonly<{
     readonly NEWSLETTER: "newsletter";
     readonly XMPP_PING: "urn:xmpp:ping";
     readonly WHATSAPP_PING: "w:p";
+    readonly ABPROPS: "abt";
+    readonly MEX: "w:mex";
 }>;

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

@@ -2,6 +2,12 @@ export declare const WA_NOTIFICATION_TYPES: Readonly<{
     readonly GROUP: "w:gp2";
     readonly ENCRYPT: "encrypt";
     readonly DEVICES: "devices";
+    readonly SERVER: "server";
+    readonly REGISTRATION: "registration";
+}>;
+export declare const WA_REGISTRATION_NOTIFICATION_TAGS: Readonly<{
+    readonly WA_OLD_REGISTRATION: "wa_old_registration";
+    readonly DEVICE_LOGOUT: "device_logout";
 }>;
 export declare const WA_GROUP_NOTIFICATION_TAGS: Readonly<{
     readonly REMOVE: "remove";

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

@@ -39,6 +39,7 @@ export declare const WA_LOGOUT_REASONS: Readonly<{
     readonly WEB_FAIL_ENC_SALT: "web_fail_enc_salt";
     readonly CACHE_STORAGE_OPEN_FAILED: "cache_storage_open_failed";
 }>;
+export type WaLogoutReason = (typeof WA_LOGOUT_REASONS)[keyof typeof WA_LOGOUT_REASONS];
 export declare const WA_STREAM_SIGNALING: Readonly<{
     readonly STREAM_ERROR_TAG: "stream:error";
     readonly XML_STREAM_END_TAG: "xmlstreamend";

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

@@ -1,2 +1,2 @@
 import { type WaRetryReasonCode } from './constants';
-export declare function mapRetryReasonFromError(error: unknown): WaRetryReasonCode;
+export declare function mapRetryReasonFromError(error: unknown): WaRetryReasonCode | undefined;

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

@@ -1,11 +1,13 @@
 import type { Logger } from '../../infra/log/types';
 import type { RegistrationInfo, SignedPreKeyRecord } from '../types';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface SignalDigestSyncApiOptions {
     readonly logger: Logger;
     readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
     readonly signalStore: WaSignalStore;
+    readonly preKeyStore: WaPreKeyStore;
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
 }
@@ -23,6 +25,7 @@ export declare class SignalDigestSyncApi {
     private readonly logger;
     private readonly query;
     private readonly signalStore;
+    private readonly preKeyStore;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
     constructor(options: SignalDigestSyncApiOptions);

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

@@ -1,5 +1,5 @@
 import type { Logger } from '../../infra/log/types';
-import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { WaIdentityStore } from '../../store/contracts/identity.store';
 import type { BinaryNode } from '../../transport/types';
 export interface SignalIdentitySyncEntry {
     readonly jid: string;
@@ -9,14 +9,14 @@ export interface SignalIdentitySyncEntry {
 interface SignalIdentitySyncApiOptions {
     readonly logger: Logger;
     readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
-    readonly signalStore?: WaSignalStore;
+    readonly identityStore?: WaIdentityStore;
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
 }
 export declare class SignalIdentitySyncApi {
     private readonly logger;
     private readonly query;
-    private readonly signalStore?;
+    private readonly identityStore?;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
     private readonly syncDedup;

package/dist/types/signal/crypto/WaAdvSignature.d.ts

@@ -1,7 +1,5 @@
 import type { SignalKeyPair } from '../../crypto/curves/types';
 export { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE } from '../crypto/constants';
-export declare function verifySignalSignature(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
-export declare function signSignalMessage(privateKey: Uint8Array, message: Uint8Array): Promise<Uint8Array>;
 export declare function verifyDeviceIdentityAccountSignature(details: Uint8Array, accountSignature: Uint8Array, identityPublicKey: Uint8Array, accountSignatureKey: Uint8Array, isHosted?: boolean): Promise<boolean>;
 export declare function generateDeviceSignature(details: Uint8Array, identityKeyPair: SignalKeyPair, accountSignatureKey: Uint8Array, isHosted?: boolean): Promise<Uint8Array>;
 export declare function computeAdvIdentityHmac(secretKey: Uint8Array, details: Uint8Array): Promise<Uint8Array>;

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

@@ -1,4 +1,3 @@
-export declare const SIGNAL_PREFIX_SIGNATURE_RANDOM: Uint8Array<ArrayBuffer>;
 export declare const ADV_PREFIX_ACCOUNT_SIGNATURE: Uint8Array<ArrayBuffer>;
 export declare const ADV_PREFIX_DEVICE_SIGNATURE: Uint8Array<ArrayBuffer>;
 export declare const ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE: Uint8Array<ArrayBuffer>;

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

@@ -1,4 +1,5 @@
-import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from './types';
+import { type Proto } from '..';
+import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalMessageKey, SignalRecvChain, SignalSessionRecord, SignalSessionSnapshot, SignedPreKeyRecord } from './types';
 export interface SignalAddressParts {
     readonly user: string;
     readonly server: string;
@@ -63,6 +64,11 @@ export declare function decodeSignalAddressFromRow(row: Pick<SenderKeyRow | Send
 export declare function decodeSignalRegistrationRow(row: SignalRegistrationRow): RegistrationInfo;
 export declare function decodeSignalPreKeyRow(row: SignalPreKeyRow): PreKeyRecord;
 export declare function decodeSignalSignedPreKeyRow(row: SignalSignedPreKeyRow): SignedPreKeyRecord;
+export declare function encodeSignalSessionSnapshot(session: SignalSessionSnapshot): Proto.ISessionStructure;
+export declare function encodeSignalRecvChain(chain: SignalRecvChain): Proto.SessionStructure.IChain;
+export declare function decodeSignalMessageKey(messageKey: Proto.SessionStructure.Chain.IMessageKey, field: string): SignalMessageKey;
+export declare function decodeSignalRecvChain(chain: Proto.SessionStructure.IChain, field: string): SignalRecvChain;
+export declare function decodeSignalSessionSnapshot(session: Proto.ISessionStructure, field: string): SignalSessionSnapshot;
 export declare function encodeSignalSessionRecord(record: SignalSessionRecord): Uint8Array;
 export declare function decodeSignalSessionRecord(raw: unknown): SignalSessionRecord;
 export declare function encodeSenderKeyRecord(record: SenderKeyRecord): Uint8Array;

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

@@ -7,5 +7,5 @@ export interface SenderKeyMessageKeySelection {
     readonly messageKey: SenderMessageKey;
     readonly updatedRecord: SenderKeyRecord;
 }
-export declare function selectMessageKey(senderKey: SenderKeyRecord, targetIteration: number): Promise<SenderKeyMessageKeySelection>;
+export declare function selectMessageKey(senderKey: SenderKeyRecord, targetIteration: number, futureMessagesMax?: number): Promise<SenderKeyMessageKeySelection>;
 export declare function deriveSenderKeyMsgKey(iteration: number, chainKey: Uint8Array): Promise<SenderKeyMessageKeyDerivation>;

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

@@ -1,4 +1,4 @@
-import type { Proto } from '../..';
+import { type Proto } from '../..';
 import type { SenderKeyRecord, SignalAddress } from '../types';
 import type { WaSenderKeyStore } from '../../store/contracts/sender-key.store';
 interface GroupSenderKeyCiphertext {
@@ -11,7 +11,12 @@ interface GroupSenderKeyCiphertext {
 export declare class SenderKeyManager {
     private readonly store;
     private readonly senderLock;
-    constructor(store: WaSenderKeyStore);
+    private readonly getFutureMessagesMax;
+    private readonly skipSignatureVerification;
+    constructor(store: WaSenderKeyStore, options?: {
+        readonly getFutureMessagesMax?: () => number;
+        readonly skipSignatureVerification?: boolean;
+    });
     prepareGroupEncryption(groupId: string, sender: SignalAddress, plaintext: Uint8Array): Promise<{
         readonly distributionMessage: Proto.Message.ISenderKeyDistributionMessage;
         readonly ciphertext: GroupSenderKeyCiphertext;

package/dist/types/signal/registration/utils.d.ts

@@ -1,9 +1,10 @@
 import type { PreKeyRecord, RegistrationInfo, SignedPreKeyRecord } from '../types';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 interface RegistrationBundle {
     readonly registrationInfo: RegistrationInfo;
     readonly signedPreKey: SignedPreKeyRecord;
     readonly firstPreKey: PreKeyRecord;
 }
-export declare function createAndStoreInitialKeys(store: WaSignalStore): Promise<RegistrationBundle>;
+export declare function createAndStoreInitialKeys(store: WaSignalStore, preKeyStore: WaPreKeyStore): Promise<RegistrationBundle>;
 export {};

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

@@ -1,14 +1,23 @@
 import type { Logger } from '../../infra/log/types';
 import type { SignalAddress, SignalPreKeyBundle, SignalSessionRecord } from '../types';
+import type { WaIdentityStore } from '../../store/contracts/identity.store';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
+import type { WaSessionStore } from '../../store/contracts/session.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 interface EstablishOutgoingSessionOptions {
     readonly reuseExisting?: boolean;
 }
+export interface SignalProtocolStores {
+    readonly signal: WaSignalStore;
+    readonly preKey: WaPreKeyStore;
+    readonly session: WaSessionStore;
+    readonly identity: WaIdentityStore;
+}
 export declare class SignalProtocol {
-    private readonly store;
+    private readonly stores;
     private readonly logger;
     private readonly sessionMutationLock;
-    constructor(store: WaSignalStore, logger?: Logger);
+    constructor(stores: SignalProtocolStores, logger?: Logger);
     establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle, options?: EstablishOutgoingSessionOptions): Promise<SignalSessionRecord>;
     encryptMessage(address: SignalAddress, plaintext: Uint8Array, expectedIdentity?: Uint8Array): Promise<{
         readonly type: 'msg' | 'pkmsg';

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

@@ -1,6 +1,7 @@
 import type { ParsedPreKeySignalMessage, ParsedSignalMessage, PreKeyRecord, SignedPreKeyRecord } from '../types';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 export declare function deserializeMsg(versionContentMac: Uint8Array): ParsedSignalMessage;
 export declare function deserializePkMsg(versionContent: Uint8Array): ParsedPreKeySignalMessage;
 export declare function requireSignedPreKey(store: WaSignalStore, id: number): Promise<SignedPreKeyRecord>;
-export declare function requirePreKey(store: WaSignalStore, id: number): Promise<PreKeyRecord>;
+export declare function requirePreKey(store: WaPreKeyStore, id: number): Promise<PreKeyRecord>;

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

@@ -3,7 +3,8 @@ import type { SignalIdentitySyncApi } from '../api/SignalIdentitySyncApi';
 import type { SignalSessionSyncApi } from '../api/SignalSessionSyncApi';
 import type { SignalProtocol } from '../session/SignalProtocol';
 import type { SignalAddress, SignalSessionRecord } from '../types';
-import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { WaIdentityStore } from '../../store/contracts/identity.store';
+import type { WaSessionStore } from '../../store/contracts/session.store';
 export interface SignalResolvedSessionTarget {
     readonly jid: string;
     readonly address: SignalAddress;
@@ -15,7 +16,8 @@ export type SignalSessionResolver = {
 };
 export declare function createSignalSessionResolver(options: {
     readonly signalProtocol: SignalProtocol;
-    readonly signalStore: WaSignalStore;
+    readonly sessionStore: WaSessionStore;
+    readonly identityStore: WaIdentityStore;
     readonly signalIdentitySync: SignalIdentitySyncApi;
     readonly signalSessionSync: SignalSessionSyncApi;
     readonly logger: Logger;

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

@@ -1,4 +1,5 @@
 import type { SignalKeyPair } from '../crypto/curves/types';
+import type { Proto } from '..';
 export interface RegistrationInfo {
     readonly registrationId: number;
     readonly identityKeyPair: SignalKeyPair;
@@ -37,8 +38,14 @@ export interface SignalRecvChain {
     readonly ratchetPubKey: Uint8Array;
     readonly nextMsgIndex: number;
     readonly chainKey: Uint8Array;
-    readonly unusedMsgKeys: readonly SignalMessageKey[];
-}
+    readonly unusedMsgKeys: readonly Proto.SessionStructure.Chain.IMessageKey[];
+}
+/**
+ * Raw protobuf recv chain kept as-is to avoid eager decode.
+ * Use {@link decodeSignalRecvChain} only for the chain that
+ * actually needs to be read/modified.
+ */
+export type RawSignalRecvChain = Proto.SessionStructure.IChain;
 export interface SignalSendChain {
     readonly ratchetKey: SignalSerializedKeyPair;
     readonly nextMsgIndex: number;
@@ -54,14 +61,19 @@ export interface SignalSessionSnapshot {
     readonly remote: SignalPeer;
     readonly rootKey: Uint8Array;
     readonly sendChain: SignalSendChain;
-    readonly recvChains: readonly SignalRecvChain[];
+    readonly recvChains: readonly RawSignalRecvChain[];
     readonly initialExchangeInfo: SignalInitialExchangeInfo | null;
     readonly prevSendChainHighestIndex: number;
     readonly aliceBaseKey: Uint8Array | null;
 }
 export interface SignalSessionRecord extends SignalSessionSnapshot {
-    readonly prevSessions: readonly SignalSessionSnapshot[];
+    readonly prevSessions: readonly RawSignalSessionSnapshot[];
 }
+/**
+ * Raw protobuf session snapshot kept as-is to avoid eager decode.
+ * Only decoded on demand in rare fallback paths (session mismatch).
+ */
+export type RawSignalSessionSnapshot = Proto.ISessionStructure;
 export interface SignalPreKeyBundle {
     readonly regId: number;
     readonly identity: Uint8Array;

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

@@ -0,0 +1,11 @@
+import type { SignalAddress } from '../../signal/types';
+export interface WaIdentityStore {
+    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
+    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
+    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
+    setRemoteIdentities(entries: readonly {
+        readonly address: SignalAddress;
+        readonly identityKey: Uint8Array;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/store/contracts/message-secret.store.d.ts

@@ -0,0 +1,16 @@
+export interface WaMessageSecretEntry {
+    readonly secret: Uint8Array;
+    readonly senderJid: string;
+}
+export interface WaMessageSecretStore {
+    get(messageId: string, nowMs?: number): Promise<WaMessageSecretEntry | null>;
+    getBatch(messageIds: readonly string[], nowMs?: number): Promise<readonly (WaMessageSecretEntry | null)[]>;
+    set(messageId: string, entry: WaMessageSecretEntry): Promise<void>;
+    setBatch(entries: readonly {
+        readonly messageId: string;
+        readonly entry: WaMessageSecretEntry;
+    }[]): Promise<void>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+    destroy?(): Promise<void>;
+}

package/dist/types/store/contracts/pre-key.store.d.ts

@@ -0,0 +1,13 @@
+import type { PreKeyRecord } from '../../signal/types';
+export interface WaPreKeyStore {
+    putPreKey(record: PreKeyRecord): Promise<void>;
+    getOrGenPreKeys(count: number, generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<readonly PreKeyRecord[]>;
+    getPreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getPreKeysById(keyIds: readonly number[]): Promise<readonly (PreKeyRecord | null)[]>;
+    consumePreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getOrGenSinglePreKey(generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<PreKeyRecord>;
+    markKeyAsUploaded(keyId: number): Promise<void>;
+    setServerHasPreKeys(value: boolean): Promise<void>;
+    getServerHasPreKeys(): Promise<boolean>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+import type { SignalAddress, SignalSessionRecord } from '../../signal/types';
+export interface WaSessionStore {
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
+    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    setSessionsBatch(entries: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
+    }[]): Promise<void>;
+    deleteSession(address: SignalAddress): Promise<void>;
+    clear(): Promise<void>;
+}