zapo-js 0.1.0

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

@@ -0,0 +1,14 @@
+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;
+export declare const SENDER_KEY_FUTURE_MESSAGES_MAX = 20000;
+export declare const MESSAGE_KEY_LABEL: Uint8Array<ArrayBuffer>;
+export declare const CHAIN_KEY_LABEL: Uint8Array<ArrayBuffer>;
+export declare const WHISPER_GROUP_INFO: NodeJS.NonSharedUint8Array;
+export declare const SIGNAL_PREFIX: Uint8Array<ArrayBuffer>;

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,5 @@
+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>;
+export declare const ADV_PREFIX_HOSTED_DEVICE_SIGNATURE: Uint8Array<ArrayBuffer>;

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

@@ -0,0 +1,11 @@
+import type { SenderKeyRecord, SenderMessageKey } from '../types';
+export interface SenderKeyMessageKeyDerivation {
+    readonly nextChainKey: Uint8Array;
+    readonly messageKey: SenderMessageKey;
+}
+export interface SenderKeyMessageKeySelection {
+    readonly messageKey: SenderMessageKey;
+    readonly updatedRecord: SenderKeyRecord;
+}
+export declare function selectMessageKey(senderKey: SenderKeyRecord, targetIteration: number): Promise<SenderKeyMessageKeySelection>;
+export declare function deriveSenderKeyMsgKey(iteration: number, chainKey: Uint8Array): Promise<SenderKeyMessageKeyDerivation>;

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

@@ -0,0 +1,14 @@
+export interface ParsedDistributionPayload {
+    readonly keyId: number;
+    readonly iteration: number;
+    readonly chainKey: Uint8Array;
+    readonly signingPublicKey: Uint8Array;
+}
+export interface ParsedSenderKeyMessage {
+    readonly keyId: number;
+    readonly iteration: number;
+    readonly ciphertext: Uint8Array;
+    readonly versionContentMac: Uint8Array;
+}
+export declare function parseDistributionPayload(payload: Uint8Array): ParsedDistributionPayload;
+export declare function parseSenderKeyMessage(versionContentMac: Uint8Array): ParsedSenderKeyMessage;

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

@@ -0,0 +1,22 @@
+import type { Proto } from '../..';
+import type { SenderKeyRecord, SignalAddress } from '../types';
+import type { WaSenderKeyStore } from '../../store/contracts/sender-key.store';
+interface GroupSenderKeyCiphertext {
+    readonly groupId: string;
+    readonly sender: SignalAddress;
+    readonly keyId?: number;
+    readonly iteration?: number;
+    readonly ciphertext: Uint8Array;
+}
+export declare class SenderKeyManager {
+    private readonly store;
+    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>;
+    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;
+}
+export {};

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

@@ -0,0 +1,12 @@
+export { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalPreKeyBundle, SignedPreKeyRecord } from './types';
+export { generatePreKeyPair, generateRegistrationId, generateRegistrationInfo, generateSignedPreKey } from './registration/keygen';
+export { buildPreKeyUploadIq, parsePreKeyUploadFailure } from './api/prekeys';
+export { SignalDigestSyncApi } from './api/SignalDigestSyncApi';
+export { SignalDeviceSyncApi } from './api/SignalDeviceSyncApi';
+export { SignalIdentitySyncApi } from './api/SignalIdentitySyncApi';
+export { SignalMissingPreKeysSyncApi } from './api/SignalMissingPreKeysSyncApi';
+export { SignalRotateKeyApi } from './api/SignalRotateKeyApi';
+export { SignalSessionSyncApi } from './api/SignalSessionSyncApi';
+export { SenderKeyManager } from './group/SenderKeyManager';
+export { createAndStoreInitialKeys } from './registration/utils';
+export { SignalProtocol } from './session/SignalProtocol';

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

@@ -0,0 +1,5 @@
+import type { PreKeyRecord, RegistrationInfo, SignedPreKeyRecord } from '../types';
+export declare function generateRegistrationInfo(): Promise<RegistrationInfo>;
+export declare function generatePreKeyPair(keyId: number): Promise<PreKeyRecord>;
+export declare function generateSignedPreKey(keyId: number, signingPrivateKey: Uint8Array): Promise<SignedPreKeyRecord>;
+export declare function generateRegistrationId(): Promise<number>;

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

@@ -0,0 +1,9 @@
+import type { PreKeyRecord, RegistrationInfo, SignedPreKeyRecord } from '../types';
+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 {};

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

@@ -0,0 +1,22 @@
+import type { Logger } from '../../infra/log/types';
+import type { SignalAddress, SignalPreKeyBundle, SignalSessionRecord } from '../types';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+export declare class SignalProtocol {
+    private readonly store;
+    private readonly logger;
+    constructor(store: WaSignalStore, logger?: Logger);
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    establishOutgoingSession(address: SignalAddress, remoteBundle: SignalPreKeyBundle): Promise<SignalSessionRecord>;
+    encryptMessage(address: SignalAddress, plaintext: Uint8Array, expectedIdentity?: Uint8Array): Promise<{
+        readonly type: 'msg' | 'pkmsg';
+        readonly ciphertext: Uint8Array;
+        readonly baseKey: Uint8Array | null;
+    }>;
+    decryptMessage(address: SignalAddress, envelope: {
+        readonly type: 'msg' | 'pkmsg';
+        readonly ciphertext: Uint8Array;
+    }): Promise<Uint8Array>;
+    private decryptMsgInternal;
+    private decryptPkMsg;
+}

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

@@ -0,0 +1,25 @@
+import type { ParsedPreKeySignalMessage, ParsedSignalMessage, SignalMessageKey, SignalRecvChain, SignalSessionRecord } from '../types';
+export interface DecryptOutcome {
+    readonly updatedSession: SignalSessionRecord;
+    readonly plaintext: Uint8Array;
+    readonly newSessionInfo: {
+        readonly newIdentity: Uint8Array | null;
+        readonly baseSession: SignalSessionRecord;
+        readonly usedPreKey: number | null;
+    } | null;
+}
+export declare function splitMsgKey(index: number, bytes: Uint8Array): SignalMessageKey;
+export declare function deriveMsgKey(index: number, chainKey: Uint8Array): Promise<{
+    readonly nextChainKey: Uint8Array;
+    readonly messageKey: SignalMessageKey;
+}>;
+export declare function selectMessageKey(chain: SignalRecvChain, targetCounter: number): Promise<{
+    readonly messageKey: SignalMessageKey;
+    readonly updatedChain: SignalRecvChain;
+}>;
+export declare function encryptMsg(session: SignalSessionRecord, plaintext: Uint8Array): Promise<readonly [SignalSessionRecord, {
+    type: 'msg' | 'pkmsg';
+    ciphertext: Uint8Array;
+}]>;
+export declare function decryptMsg(session: SignalSessionRecord | null, parsed: ParsedSignalMessage, onPrevSessionDecryptError?: (error: Error, previousSessionIndex: number) => void): Promise<DecryptOutcome>;
+export declare function decryptMsgFromSession(session: SignalSessionRecord, message: ParsedSignalMessage | ParsedPreKeySignalMessage): Promise<readonly [SignalSessionRecord, Uint8Array]>;

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

@@ -0,0 +1,6 @@
+import type { ParsedPreKeySignalMessage, ParsedSignalMessage, PreKeyRecord, SignedPreKeyRecord } from '../types';
+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>;

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

@@ -0,0 +1,43 @@
+import type { SignalSerializedKeyPair, SignalSessionRecord, SignalSessionSnapshot } from '../types';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+interface LocalIdentityContext {
+    readonly regId: number;
+    readonly staticKeyPair: SignalSerializedKeyPair;
+}
+interface IncomingRatchetKeys {
+    readonly signed: SignalSerializedKeyPair;
+    readonly oneTime?: SignalSerializedKeyPair;
+    readonly ratchet: SignalSerializedKeyPair;
+}
+export declare function snapshotToRecord(snapshot: SignalSessionSnapshot): SignalSessionRecord;
+export declare function detachSession(session: SignalSessionRecord): SignalSessionSnapshot;
+export declare function findMatchingSession(session: SignalSessionRecord | null, sessionBaseKey: Uint8Array): SignalSessionRecord | null;
+export declare function requireLocalIdentity(store: WaSignalStore): Promise<LocalIdentityContext>;
+export declare function initiateSessionOutgoing(local: LocalIdentityContext, remoteBundle: {
+    identity: Uint8Array;
+    signedKey: {
+        id: number;
+        publicKey: Uint8Array;
+    };
+    oneTimeKey?: {
+        id: number;
+        publicKey: Uint8Array;
+    };
+    ratchetKey?: Uint8Array;
+    regId: number;
+}, localOneTimeBase: SignalSerializedKeyPair): Promise<SignalSessionRecord>;
+export declare function initiateSessionIncoming(local: LocalIdentityContext, remote: {
+    regId: number;
+    pubKey: Uint8Array;
+}, sessionBaseKey: Uint8Array, localKeys: IncomingRatchetKeys): Promise<SignalSessionRecord>;
+export declare function calculateRatchet(rootKey: Uint8Array, localRatchet: SignalSerializedKeyPair, remoteRatchetPubKey: Uint8Array): Promise<{
+    readonly rootKey: Uint8Array;
+    readonly chainKey: Uint8Array;
+}>;
+export declare function generateSerializedKeyPair(): Promise<SignalSerializedKeyPair>;
+export declare function toSerializedKeyPair(pair: {
+    readonly pubKey: Uint8Array;
+    readonly privKey: Uint8Array;
+}): SignalSerializedKeyPair;
+export declare function ecdh(privateKey: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+export {};

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

@@ -0,0 +1,72 @@
+import type { PreKeyRecord, RegistrationInfo, SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../types';
+export interface SignalAddressParts {
+    readonly user: string;
+    readonly server: string;
+    readonly device: number;
+}
+export interface SignalRegistrationRow extends Record<string, unknown> {
+    readonly registration_id: unknown;
+    readonly identity_pub_key: unknown;
+    readonly identity_priv_key: unknown;
+}
+export interface SignalSignedPreKeyRow extends Record<string, unknown> {
+    readonly key_id: unknown;
+    readonly pub_key: unknown;
+    readonly priv_key: unknown;
+    readonly signature: unknown;
+    readonly uploaded: unknown;
+}
+export interface SignalPreKeyRow extends Record<string, unknown> {
+    readonly key_id: unknown;
+    readonly pub_key: unknown;
+    readonly priv_key: unknown;
+    readonly uploaded: unknown;
+}
+export interface SignalMetaRow extends Record<string, unknown> {
+    readonly server_has_prekeys: unknown;
+    readonly next_prekey_id: unknown;
+    readonly signed_prekey_rotation_ts: unknown;
+}
+export interface SignalSessionRow extends Record<string, unknown> {
+    readonly user: unknown;
+    readonly server: unknown;
+    readonly device: unknown;
+    readonly record: unknown;
+}
+export interface SignalIdentityRow extends Record<string, unknown> {
+    readonly identity_key: unknown;
+}
+export interface SenderKeyRow extends Record<string, unknown> {
+    readonly group_id: unknown;
+    readonly sender_user: unknown;
+    readonly sender_server: unknown;
+    readonly sender_device: unknown;
+    readonly record: unknown;
+}
+export interface SenderKeyDistributionRow extends Record<string, unknown> {
+    readonly group_id: unknown;
+    readonly sender_user: unknown;
+    readonly sender_server: unknown;
+    readonly sender_device: unknown;
+    readonly key_id: unknown;
+    readonly timestamp_ms: unknown;
+}
+export interface SqliteCountRow extends Record<string, unknown> {
+    readonly count: unknown;
+}
+export declare function toSignalAddressParts(address: SignalAddress): SignalAddressParts;
+export declare function decodeSignalAddressFromRow(row: Pick<SenderKeyRow | SenderKeyDistributionRow | SignalSessionRow, 'sender_user' | 'sender_server' | 'sender_device'> | {
+    readonly sender_user?: unknown;
+    readonly sender_server?: unknown;
+    readonly sender_device?: unknown;
+}): SignalAddress;
+export declare function decodeSignalRegistrationRow(row: SignalRegistrationRow): RegistrationInfo;
+export declare function decodeSignalPreKeyRow(row: SignalPreKeyRow): PreKeyRecord;
+export declare function decodeSignalSignedPreKeyRow(row: SignalSignedPreKeyRow): SignedPreKeyRecord;
+export declare function encodeSignalSessionRecord(record: SignalSessionRecord): Uint8Array;
+export declare function decodeSignalSessionRecord(raw: unknown): SignalSessionRecord;
+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 decodeSignalRemoteIdentity(raw: unknown): Uint8Array;

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

@@ -0,0 +1,110 @@
+import type { SignalKeyPair } from '../crypto/curves/types';
+export interface RegistrationInfo {
+    readonly registrationId: number;
+    readonly identityKeyPair: SignalKeyPair;
+}
+export interface PreKeyRecord {
+    readonly keyId: number;
+    readonly keyPair: SignalKeyPair;
+    readonly uploaded?: boolean;
+}
+export interface SignedPreKeyRecord {
+    readonly keyId: number;
+    readonly keyPair: SignalKeyPair;
+    readonly signature: Uint8Array;
+    readonly uploaded?: boolean;
+}
+export interface SignalAddress {
+    readonly user: string;
+    readonly server?: string;
+    readonly device: number;
+}
+export interface SignalPeer {
+    readonly regId: number;
+    readonly pubKey: Uint8Array;
+}
+export interface SignalSerializedKeyPair {
+    readonly pubKey: Uint8Array;
+    readonly privKey: Uint8Array;
+}
+export interface SignalMessageKey {
+    readonly index: number;
+    readonly cipherKey: Uint8Array;
+    readonly macKey: Uint8Array;
+    readonly iv: Uint8Array;
+}
+export interface SignalRecvChain {
+    readonly ratchetPubKey: Uint8Array;
+    readonly nextMsgIndex: number;
+    readonly chainKey: Uint8Array;
+    readonly unusedMsgKeys: readonly SignalMessageKey[];
+}
+export interface SignalSendChain {
+    readonly ratchetKey: SignalSerializedKeyPair;
+    readonly nextMsgIndex: number;
+    readonly chainKey: Uint8Array;
+}
+export interface SignalInitialExchangeInfo {
+    readonly remoteOneTimeId: number | null;
+    readonly remoteSignedId: number;
+    readonly localOneTimePubKey: Uint8Array;
+}
+export interface SignalSessionSnapshot {
+    readonly local: SignalPeer;
+    readonly remote: SignalPeer;
+    readonly rootKey: Uint8Array;
+    readonly sendChain: SignalSendChain;
+    readonly recvChains: readonly SignalRecvChain[];
+    readonly initialExchangeInfo: SignalInitialExchangeInfo | null;
+    readonly prevSendChainHighestIndex: number;
+    readonly aliceBaseKey: Uint8Array | null;
+}
+export interface SignalSessionRecord extends SignalSessionSnapshot {
+    readonly prevSessions: readonly SignalSessionSnapshot[];
+}
+export interface SignalPreKeyBundle {
+    readonly regId: number;
+    readonly identity: Uint8Array;
+    readonly signedKey: {
+        readonly id: number;
+        readonly publicKey: Uint8Array;
+        readonly signature: Uint8Array;
+    };
+    readonly oneTimeKey?: {
+        readonly id: number;
+        readonly publicKey: Uint8Array;
+    };
+    readonly ratchetKey?: Uint8Array;
+}
+export interface ParsedSignalMessage {
+    readonly ratchetPubKey: Uint8Array;
+    readonly counter: number;
+    readonly ciphertext: Uint8Array;
+    readonly versionContentMac: Uint8Array;
+}
+export interface ParsedPreKeySignalMessage extends ParsedSignalMessage {
+    readonly remote: SignalPeer;
+    readonly sessionBaseKey: Uint8Array;
+    readonly localSignedPreKeyId: number;
+    readonly localOneTimeKeyId: number | null;
+}
+export interface SenderKeyRecord {
+    readonly groupId: string;
+    readonly sender: SignalAddress;
+    readonly keyId: number;
+    readonly iteration: number;
+    readonly chainKey: Uint8Array;
+    readonly signingPublicKey: Uint8Array;
+    readonly signingPrivateKey?: Uint8Array;
+    readonly unusedMessageKeys?: readonly SenderMessageKey[];
+}
+export interface SenderMessageKey {
+    readonly iteration: number;
+    readonly seed: Uint8Array;
+}
+export interface SenderKeyDistributionRecord {
+    readonly groupId: string;
+    readonly sender: SignalAddress;
+    readonly keyId: number;
+    readonly timestampMs: number;
+}

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

@@ -0,0 +1,22 @@
+import type { AppStateCollectionName, WaAppStateStoreData, WaAppStateSyncKey } from '../../appstate/types';
+export interface WaAppStateCollectionStoreState {
+    readonly version: number;
+    readonly hash: Uint8Array;
+    readonly indexValueMap: ReadonlyMap<string, Uint8Array>;
+}
+export interface WaAppStateCollectionStateUpdate {
+    readonly collection: AppStateCollectionName;
+    readonly version: number;
+    readonly hash: Uint8Array;
+    readonly indexValueMap: ReadonlyMap<string, Uint8Array>;
+}
+export interface WaAppStateStore {
+    exportData(): Promise<WaAppStateStoreData>;
+    upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
+    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
+    getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,6 @@
+import type { WaAuthCredentials } from '../../auth/types';
+export interface WaAuthStore {
+    load(): Promise<WaAuthCredentials | null>;
+    save(credentials: WaAuthCredentials): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+export interface WaStoredContactRecord {
+    readonly jid: string;
+    readonly displayName?: string;
+    readonly pushName?: string;
+    readonly lid?: string;
+    readonly phoneNumber?: string;
+    readonly lastUpdatedMs: number;
+}
+export interface WaContactStore {
+    upsert(record: WaStoredContactRecord): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredContactRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+}

package/dist/types/store/contracts/device-list.store.d.ts

@@ -0,0 +1,16 @@
+export interface WaDeviceListSnapshot {
+    readonly userJid: string;
+    readonly deviceJids: readonly string[];
+    readonly updatedAtMs: number;
+}
+export interface WaDeviceListStore {
+    getTtlMs(): number;
+    destroy?(): Promise<void>;
+    upsertUserDevices(snapshot: WaDeviceListSnapshot): Promise<void>;
+    upsertUserDevicesBatch(snapshots: readonly WaDeviceListSnapshot[]): Promise<void>;
+    getUserDevices(userJid: string, nowMs?: number): Promise<WaDeviceListSnapshot | null>;
+    getUserDevicesBatch(userJids: readonly string[], nowMs?: number): Promise<readonly (WaDeviceListSnapshot | null)[]>;
+    deleteUserDevices(userJid: string): Promise<number>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+export interface WaStoredMessageRecord {
+    readonly id: string;
+    readonly threadJid: string;
+    readonly senderJid?: string;
+    readonly participantJid?: string;
+    readonly fromMe: boolean;
+    readonly timestampMs?: number;
+    readonly encType?: string;
+    readonly plaintext?: Uint8Array;
+    readonly messageBytes?: Uint8Array;
+}
+export interface WaMessageStore {
+    upsert(record: WaStoredMessageRecord): Promise<void>;
+    getById(id: string): Promise<WaStoredMessageRecord | null>;
+    listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
+    deleteById(id: string): Promise<number>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+export interface WaParticipantsSnapshot {
+    readonly groupJid: string;
+    readonly participants: readonly string[];
+    readonly updatedAtMs: number;
+}
+export interface WaParticipantsStore {
+    getTtlMs(): number;
+    destroy?(): Promise<void>;
+    upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
+    getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;
+    deleteGroupParticipants(groupJid: string): Promise<number>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../retry/types';
+export interface WaRetryStore {
+    getTtlMs?(): number;
+    destroy?(): Promise<void>;
+    upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
+    updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, 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/sender-key.store.d.ts

@@ -0,0 +1,16 @@
+import type { SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress } from '../../signal/types';
+export interface WaSenderKeyStore {
+    upsertSenderKey(record: SenderKeyRecord): Promise<void>;
+    upsertSenderKeyDistribution(record: SenderKeyDistributionRecord): Promise<void>;
+    upsertSenderKeyDistributions(records: readonly SenderKeyDistributionRecord[]): Promise<void>;
+    getGroupSenderKeyList(groupId: string): Promise<{
+        readonly skList: readonly SenderKeyRecord[];
+        readonly skDistribList: readonly SenderKeyDistributionRecord[];
+    }>;
+    getDeviceSenderKey(groupId: string, sender: SignalAddress): Promise<SenderKeyRecord | null>;
+    getDeviceSenderKeyDistribution(groupId: string, sender: SignalAddress): Promise<SenderKeyDistributionRecord | null>;
+    getDeviceSenderKeyDistributions(groupId: string, senders: readonly SignalAddress[]): Promise<readonly (SenderKeyDistributionRecord | null)[]>;
+    deleteDeviceSenderKey(target: SignalAddress, groupId?: string): Promise<number>;
+    markForgetSenderKey(groupId: string, participants: readonly SignalAddress[]): Promise<number>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../signal/types';
+export interface WaSignalStore {
+    getRegistrationInfo(): Promise<RegistrationInfo | null>;
+    setRegistrationInfo(info: RegistrationInfo): Promise<void>;
+    getSignedPreKey(): Promise<SignedPreKeyRecord | null>;
+    setSignedPreKey(record: SignedPreKeyRecord): Promise<void>;
+    getSignedPreKeyById(keyId: number): Promise<SignedPreKeyRecord | null>;
+    setSignedPreKeyRotationTs(value: number | null): Promise<void>;
+    getSignedPreKeyRotationTs(): Promise<number | null>;
+    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>;
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    deleteSession(address: SignalAddress): Promise<void>;
+    getRemoteIdentity(address: SignalAddress): Promise<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/thread.store.d.ts

@@ -0,0 +1,17 @@
+export interface WaStoredThreadRecord {
+    readonly jid: string;
+    readonly name?: string;
+    readonly unreadCount?: number;
+    readonly archived?: boolean;
+    readonly pinned?: number;
+    readonly muteEndMs?: number;
+    readonly markedAsUnread?: boolean;
+    readonly ephemeralExpiration?: number;
+}
+export interface WaThreadStore {
+    upsert(record: WaStoredThreadRecord): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
+    list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+}

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

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

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

@@ -0,0 +1,31 @@
+export type { WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaSqliteDriver, WaSqliteStorageOptions, WaStoreSqliteBatchSizeSelection, WaStoreMemoryLimitSelection, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStore, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession } from './types';
+export { WaAuthSqliteStore } from './providers/sqlite/auth.store';
+export { WaAppStateSqliteStore } from './providers/sqlite/appstate.store';
+export { createStore } from './createStore';
+export type { WaAuthStore } from './contracts/auth.store';
+export type { WaContactStore, WaStoredContactRecord } from './contracts/contact.store';
+export type { WaDeviceListSnapshot, WaDeviceListStore } from './contracts/device-list.store';
+export type { WaMessageStore, WaStoredMessageRecord } from './contracts/message.store';
+export type { WaParticipantsSnapshot, WaParticipantsStore } from './contracts/participants.store';
+export type { WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
+export type { WaSenderKeyStore } from './contracts/sender-key.store';
+export type { WaSignalStore } from './contracts/signal.store';
+export type { WaRetryStore } from './contracts/retry.store';
+export type { WaStoredThreadRecord, WaThreadStore } from './contracts/thread.store';
+export { WaSignalSqliteStore } from './providers/sqlite/signal.store';
+export { SenderKeySqliteStore } from './providers/sqlite/sender-key.store';
+export { WaRetrySqliteStore } from './providers/sqlite/retry.store';
+export { WaParticipantsSqliteStore } from './providers/sqlite/participants.store';
+export { WaDeviceListSqliteStore } from './providers/sqlite/device-list.store';
+export { WaAppStateMemoryStore } from './providers/memory/appstate.store';
+export { WaSignalMemoryStore } from './providers/memory/signal.store';
+export { SenderKeyMemoryStore } from './providers/memory/sender-key.store';
+export { WaRetryMemoryStore } from './providers/memory/retry.store';
+export { WaParticipantsMemoryStore } from './providers/memory/participants.store';
+export { WaDeviceListMemoryStore } from './providers/memory/device-list.store';
+export { WaContactMemoryStore } from './providers/memory/contact.store';
+export { WaMessageMemoryStore } from './providers/memory/message.store';
+export { WaThreadMemoryStore } from './providers/memory/thread.store';
+export { WaContactSqliteStore } from './providers/sqlite/contact.store';
+export { WaMessageSqliteStore } from './providers/sqlite/message.store';
+export { WaThreadSqliteStore } from './providers/sqlite/thread.store';

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

@@ -0,0 +1,10 @@
+import type { WaContactStore } from './contracts/contact.store';
+import type { WaDeviceListStore } from './contracts/device-list.store';
+import type { WaMessageStore } from './contracts/message.store';
+import type { WaParticipantsStore } from './contracts/participants.store';
+import type { WaThreadStore } from './contracts/thread.store';
+export declare const NOOP_MESSAGE_STORE: WaMessageStore;
+export declare const NOOP_THREAD_STORE: WaThreadStore;
+export declare const NOOP_CONTACT_STORE: WaContactStore;
+export declare const NOOP_PARTICIPANTS_STORE: WaParticipantsStore;
+export declare const NOOP_DEVICE_LIST_STORE: WaDeviceListStore;