ndikzv1 26.0.12

package/lib/Store/make-ordered-dictionary.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function makeOrderedDictionary(idGetter) {
+    const array = [];
+    const dict = {};
+    const get = (id) => dict[id];
+    const update = (item) => {
+        const id = idGetter(item);
+        const idx = array.findIndex(i => idGetter(i) === id);
+        if (idx >= 0) {
+            array[idx] = item;
+            dict[id] = item;
+        }
+        return false;
+    };
+    const upsert = (item, mode) => {
+        const id = idGetter(item);
+        if (get(id)) {
+            update(item);
+        }
+        else {
+            if (mode === 'append') {
+                array.push(item);
+            }
+            else {
+                array.splice(0, 0, item);
+            }
+            dict[id] = item;
+        }
+    };
+    const remove = (item) => {
+        const id = idGetter(item);
+        const idx = array.findIndex(i => idGetter(i) === id);
+        if (idx >= 0) {
+            array.splice(idx, 1);
+            delete dict[id];
+            return true;
+        }
+        return false;
+    };
+    return {
+        array,
+        get,
+        upsert,
+        update,
+        remove,
+        updateAssign: (id, update) => {
+            const item = get(id);
+            if (item) {
+                Object.assign(item, update);
+                delete dict[id];
+                dict[idGetter(item)] = item;
+                return true;
+            }
+            return false;
+        },
+        clear: () => {
+            array.splice(0, array.length);
+            for (const key of Object.keys(dict)) {
+                delete dict[key];
+            }
+        },
+        filter: (contain) => {
+            let i = 0;
+            while (i < array.length) {
+                if (!contain(array[i])) {
+                    delete dict[idGetter(array[i])];
+                    array.splice(i, 1);
+                }
+                else {
+                    i += 1;
+                }
+            }
+        },
+        toJSON: () => array,
+        fromJSON: (newItems) => {
+            array.splice(0, array.length, ...newItems);
+        }
+    };
+}
+exports.default = makeOrderedDictionary;

package/lib/Store/object-repository.d.ts

@@ -0,0 +1,10 @@
+export declare class ObjectRepository<T extends object> {
+    readonly entityMap: Map<string, T>;
+    constructor(entities?: Record<string, T>);
+    findById(id: string): T | undefined;
+    findAll(): T[];
+    upsertById(id: string, entity: T): Map<string, T>;
+    deleteById(id: string): boolean;
+    count(): number;
+    toJSON(): T[];
+}

package/lib/Store/object-repository.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectRepository = void 0;
+class ObjectRepository {
+    constructor(entities = {}) {
+        this.entityMap = new Map(Object.entries(entities));
+    }
+    findById(id) {
+        return this.entityMap.get(id);
+    }
+    findAll() {
+        return Array.from(this.entityMap.values());
+    }
+    upsertById(id, entity) {
+        return this.entityMap.set(id, { ...entity });
+    }
+    deleteById(id) {
+        return this.entityMap.delete(id);
+    }
+    count() {
+        return this.entityMap.size;
+    }
+    toJSON() {
+        return this.findAll();
+    }
+}
+exports.ObjectRepository = ObjectRepository;

package/lib/Types/Auth.d.ts

@@ -0,0 +1,109 @@
+import type { proto } from '../../WAProto';
+import { RegistrationOptions } from '../Socket/registration';
+import type { Contact } from './Contact';
+import type { MinimalMessage } from './Message';
+export type KeyPair = {
+    public: Uint8Array;
+    private: Uint8Array;
+};
+export type SignedKeyPair = {
+    keyPair: KeyPair;
+    signature: Uint8Array;
+    keyId: number;
+    timestampS?: number;
+};
+export type ProtocolAddress = {
+    name: string;
+    deviceId: number;
+};
+export type SignalIdentity = {
+    identifier: ProtocolAddress;
+    identifierKey: Uint8Array;
+};
+export type LTHashState = {
+    version: number;
+    hash: Buffer;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+};
+export type SignalCreds = {
+    readonly signedIdentityKey: KeyPair;
+    readonly signedPreKey: SignedKeyPair;
+    readonly registrationId: number;
+};
+export type AccountSettings = {
+    /** unarchive chats when a new message is received */
+    unarchiveChats: boolean;
+    /** the default mode to start new conversations with */
+    defaultDisappearingMode?: Pick<proto.IConversation, 'ephemeralExpiration' | 'ephemeralSettingTimestamp'>;
+};
+export type AuthenticationCreds = SignalCreds & {
+    readonly noiseKey: KeyPair;
+    readonly pairingEphemeralKeyPair: KeyPair;
+    advSecretKey: string;
+    me?: Contact;
+    account?: proto.IADVSignedDeviceIdentity;
+    signalIdentities?: SignalIdentity[];
+    myAppStateKeyId?: string;
+    firstUnuploadedPreKeyId: number;
+    nextPreKeyId: number;
+    lastAccountSyncTimestamp?: number;
+    platform?: string;
+    processedHistoryMessages: MinimalMessage[];
+    /** number of times history & app state has been synced */
+    accountSyncCounter: number;
+    accountSettings: AccountSettings;
+    deviceId: string;
+    phoneId: string;
+    identityId: Buffer;
+    registered: boolean;
+    backupToken: Buffer;
+    registration: RegistrationOptions;
+    pairingCode: string | undefined;
+    lastPropHash: string | undefined;
+    routingInfo: Buffer | undefined;
+};
+export type SignalDataTypeMap = {
+    'pre-key': KeyPair;
+    'session': Uint8Array;
+    'sender-key': Uint8Array;
+    'sender-key-memory': {
+        [jid: string]: boolean;
+    };
+    'app-state-sync-key': proto.Message.IAppStateSyncKeyData;
+    'app-state-sync-version': LTHashState;
+};
+export type SignalDataSet = {
+    [T in keyof SignalDataTypeMap]?: {
+        [id: string]: SignalDataTypeMap[T] | null;
+    };
+};
+type Awaitable<T> = T | Promise<T>;
+export type SignalKeyStore = {
+    get<T extends keyof SignalDataTypeMap>(type: T, ids: string[]): Awaitable<{
+        [id: string]: SignalDataTypeMap[T];
+    }>;
+    set(data: SignalDataSet): Awaitable<void>;
+    /** clear all the data in the store */
+    clear?(): Awaitable<void>;
+};
+export type SignalKeyStoreWithTransaction = SignalKeyStore & {
+    isInTransaction: () => boolean;
+    transaction<T>(exec: () => Promise<T>): Promise<T>;
+};
+export type TransactionCapabilityOptions = {
+    maxCommitRetries: number;
+    delayBetweenTriesMs: number;
+};
+export type SignalAuthState = {
+    creds: SignalCreds;
+    keys: SignalKeyStore | SignalKeyStoreWithTransaction;
+};
+export type AuthenticationState = {
+    creds: AuthenticationCreds;
+    keys: SignalKeyStore;
+};
+export {};

package/lib/Types/Auth.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Call.d.ts

@@ -0,0 +1,13 @@
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept' | 'terminate';
+export type WACallEvent = {
+    chatId: string;
+    from: string;
+    isGroup?: boolean;
+    groupJid?: string;
+    id: string;
+    date: Date;
+    isVideo?: boolean;
+    status: WACallUpdateType;
+    offline: boolean;
+    latencyMs?: number;
+};

package/lib/Types/Call.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Chat.d.ts

@@ -0,0 +1,109 @@
+import type { proto } from '../../WAProto';
+import type { AccountSettings } from './Auth';
+import type { BufferedEventData } from './Events';
+import type { ChatLabelAssociationActionBody } from './LabelAssociation';
+import type { MessageLabelAssociationActionBody } from './LabelAssociation';
+import type { MinimalMessage, WAMessageKey } from './Message';
+/** privacy settings in WhatsApp Web */
+export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
+export type WAPrivacyCallValue = 'all' | 'known';
+export type WAPrivacyMessagesValue = 'all' | 'contacts';
+export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
+export type WAPrivacyGroupAddValue = 'all' | 'contacts' | 'contact_blacklist';
+export type WAReadReceiptsValue = 'all' | 'none';
+/** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
+export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
+export declare const ALL_WA_PATCH_NAMES: readonly ["critical_block", "critical_unblock_low", "regular_high", "regular_low", "regular"];
+export type WAPatchName = typeof ALL_WA_PATCH_NAMES[number];
+export interface PresenceData {
+    lastKnownPresence: WAPresence;
+    lastSeen?: number;
+}
+export type BotListInfo = {
+    jid: string;
+    personaId: string;
+};
+export type ChatMutation = {
+    syncAction: proto.ISyncActionData;
+    index: string[];
+};
+export type WAPatchCreate = {
+    syncAction: proto.ISyncActionValue;
+    index: string[];
+    type: WAPatchName;
+    apiVersion: number;
+    operation: proto.SyncdMutation.SyncdOperation;
+};
+export type Chat = proto.IConversation & {
+    /** unix timestamp of when the last message was received in the chat */
+    lastMessageRecvTimestamp?: number;
+};
+export type ChatUpdate = Partial<Chat & {
+    /**
+     * if specified in the update,
+     * the EV buffer will check if the condition gets fulfilled before applying the update
+     * Right now, used to determine when to release an app state sync event
+     *
+     * @returns true, if the update should be applied;
+     * false if it can be discarded;
+     * undefined if the condition is not yet fulfilled
+     * */
+    conditional: (bufferedData: BufferedEventData) => boolean | undefined;
+}>;
+/**
+ * the last messages in a chat, sorted reverse-chronologically. That is, the latest message should be first in the chat
+ * for MD modifications, the last message in the array (i.e. the earlist message) must be the last message recv in the chat
+ * */
+export type LastMessageList = MinimalMessage[] | proto.SyncActionValue.ISyncActionMessageRange;
+export type ChatModification = {
+    archive: boolean;
+    lastMessages: LastMessageList;
+} | {
+    pushNameSetting: string;
+} | {
+    pin: boolean;
+} | {
+    /** mute for duration, or provide timestamp of mute to remove*/
+    mute: number | null;
+} | {
+    clear: boolean;
+} | {
+    deleteForMe: {
+        deleteMedia: boolean;
+        key: WAMessageKey;
+        timestamp: number;
+    };
+} | {
+    star: {
+        messages: {
+            id: string;
+            fromMe?: boolean;
+        }[];
+        star: boolean;
+    };
+} | {
+    markRead: boolean;
+    lastMessages: LastMessageList;
+} | {
+    delete: true;
+    lastMessages: LastMessageList;
+} | {
+    addChatLabel: ChatLabelAssociationActionBody;
+} | {
+    removeChatLabel: ChatLabelAssociationActionBody;
+} | {
+    addMessageLabel: MessageLabelAssociationActionBody;
+} | {
+    removeMessageLabel: MessageLabelAssociationActionBody;
+};
+export type InitialReceivedChatsState = {
+    [jid: string]: {
+        /** the last message received from the other party */
+        lastMsgRecvTimestamp?: number;
+        /** the absolute last message in the chat */
+        lastMsgTimestamp: number;
+    };
+};
+export type InitialAppStateSyncOptions = {
+    accountSettings: AccountSettings;
+};

package/lib/Types/Chat.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_WA_PATCH_NAMES = void 0;
+exports.ALL_WA_PATCH_NAMES = ['critical_block', 'critical_unblock_low', 'regular_high', 'regular_low', 'regular'];

package/lib/Types/Contact.d.ts

@@ -0,0 +1,23 @@
+export interface Contact {
+    /** ID either in lid or jid format **/
+    id: string;
+    /** ID in Lid (anonymous) format (@lid) **/
+    lid?: string;
+    /** ID in Phone Number format (@s.whatsapp.net)  **/
+    jid?: string;
+    /** name of the contact, you have saved on your WA */
+    name?: string;
+    /** name of the contact, the contact has set on their own on WA */
+    notify?: string;
+    /** I have no idea */
+    verifiedName?: string;
+    /**
+     * Url of the profile picture of the contact
+     *
+     * 'changed' => if the profile picture has changed
+     * null => if the profile picture has not been set (default profile picture)
+     * any other string => url of the profile picture
+     */
+    imgUrl?: string | null;
+    status?: string;
+}

package/lib/Types/Contact.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Events.d.ts

@@ -0,0 +1,199 @@
+import type { Boom } from '@hapi/boom';
+import { proto } from '../../WAProto';
+import { AuthenticationCreds } from './Auth';
+import { WACallEvent } from './Call';
+import { Chat, ChatUpdate, PresenceData } from './Chat';
+import { Contact } from './Contact';
+import { GroupMetadata, ParticipantAction, RequestJoinAction, RequestJoinMethod } from './GroupMetadata';
+import { Label } from './Label';
+import { LabelAssociation } from './LabelAssociation';
+import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message';
+import { ConnectionState } from './State';
+import { NewsletterSettingsUpdate, SubscriberAction, NewsletterViewRole } from './Newsletter';
+export type BaileysEventMap = {
+    /** connection state has been updated -- WS closed, opened, connecting etc. */
+    'connection.update': Partial<ConnectionState>;
+    /** credentials updated -- some metadata, keys or something */
+    'creds.update': Partial<AuthenticationCreds>;
+    /** set chats (history sync), everything is reverse chronologically sorted */
+    'messaging-history.set': {
+        chats: Chat[];
+        contacts: Contact[];
+        messages: WAMessage[];
+        isLatest?: boolean;
+        progress?: number | null;
+        syncType?: proto.HistorySync.HistorySyncType;
+        peerDataRequestSessionId?: string | null;
+    };
+    /** upsert chats */
+    'chats.upsert': Chat[];
+    /** update the given chats */
+    'chats.update': ChatUpdate[];
+    'chats.phoneNumberShare': {
+        lid: string;
+        jid: string;
+    };
+    /** delete chats with given ID */
+    'chats.delete': string[];
+    /** presence of contact in a chat updated */
+    'presence.update': {
+        id: string;
+        presences: {
+            [participant: string]: PresenceData;
+        };
+    };
+    'contacts.upsert': Contact[];
+    'contacts.update': Partial<Contact>[];
+    'messages.delete': {
+        keys: WAMessageKey[];
+    } | {
+        jid: string;
+        all: true;
+    };
+    'messages.update': WAMessageUpdate[];
+    'messages.media-update': {
+        key: WAMessageKey;
+        media?: {
+            ciphertext: Uint8Array;
+            iv: Uint8Array;
+        };
+        error?: Boom;
+    }[];
+    /**
+     * add/update the given messages. If they were received while the connection was online,
+     * the update will have type: "notify"
+     * if requestId is provided, then the messages was received from the phone due to it being unavailable
+     *  */
+    'messages.upsert': {
+        messages: WAMessage[];
+        type: MessageUpsertType;
+        requestId?: string;
+    };
+    /** message was reacted to. If reaction was removed -- then "reaction.text" will be falsey */
+    'messages.reaction': {
+        key: WAMessageKey;
+        reaction: proto.IReaction;
+    }[];
+    'message-receipt.update': MessageUserReceiptUpdate[];
+    'groups.upsert': GroupMetadata[];
+    'groups.update': Partial<GroupMetadata>[];
+    /** apply an action to participants in a group */
+    'group-participants.update': {
+        id: string;
+        author: string;
+        participants: string[];
+        action: ParticipantAction;
+    };
+    'group.join-request': {
+        id: string;
+        author: string;
+        participant: string;
+        action: RequestJoinAction;
+        method: RequestJoinMethod;
+    };
+    'newsletter.reaction': {
+        id: string;
+        server_id: string;
+        reaction: {
+            code?: string;
+            count?: number;
+            removed?: boolean;
+        };
+    };
+    'newsletter.view': {
+        id: string;
+        server_id: string;
+        count: number;
+    };
+    /**don't handles subscribe/unsubscribe actions */
+    'newsletter-participants.update': {
+        id: string;
+        author: string;
+        user: string;
+        new_role: NewsletterViewRole;
+        action: SubscriberAction;
+    };
+    'newsletter-settings.update': {
+        id: string;
+        update: NewsletterSettingsUpdate;
+    };
+    'blocklist.set': {
+        blocklist: string[];
+    };
+    'blocklist.update': {
+        blocklist: string[];
+        type: 'add' | 'remove';
+    };
+    /** Receive an update on a call, including when the call was received, rejected, accepted */
+    'call': WACallEvent[];
+    'labels.edit': Label;
+    'labels.association': {
+        association: LabelAssociation;
+        type: 'add' | 'remove';
+    };
+};
+export type BufferedEventData = {
+    historySets: {
+        chats: {
+            [jid: string]: Chat;
+        };
+        contacts: {
+            [jid: string]: Contact;
+        };
+        messages: {
+            [uqId: string]: WAMessage;
+        };
+        empty: boolean;
+        isLatest: boolean;
+        progress?: number | null;
+        syncType?: proto.HistorySync.HistorySyncType;
+        peerDataRequestSessionId?: string;
+    };
+    chatUpserts: {
+        [jid: string]: Chat;
+    };
+    chatUpdates: {
+        [jid: string]: ChatUpdate;
+    };
+    chatDeletes: Set<string>;
+    contactUpserts: {
+        [jid: string]: Contact;
+    };
+    contactUpdates: {
+        [jid: string]: Partial<Contact>;
+    };
+    messageUpserts: {
+        [key: string]: {
+            type: MessageUpsertType;
+            message: WAMessage;
+        };
+    };
+    messageUpdates: {
+        [key: string]: WAMessageUpdate;
+    };
+    messageDeletes: {
+        [key: string]: WAMessageKey;
+    };
+    messageReactions: {
+        [key: string]: {
+            key: WAMessageKey;
+            reactions: proto.IReaction[];
+        };
+    };
+    messageReceipts: {
+        [key: string]: {
+            key: WAMessageKey;
+            userReceipt: proto.IUserReceipt[];
+        };
+    };
+    groupUpdates: {
+        [jid: string]: Partial<GroupMetadata>;
+    };
+};
+export type BaileysEvent = keyof BaileysEventMap;
+export interface BaileysEventEmitter {
+    on<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void;
+    off<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void;
+    removeAllListeners<T extends keyof BaileysEventMap>(event: T): void;
+    emit<T extends keyof BaileysEventMap>(event: T, arg: BaileysEventMap[T]): boolean;
+}

package/lib/Types/Events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/GroupMetadata.d.ts

@@ -0,0 +1,64 @@
+import { Contact } from './Contact';
+export type GroupParticipant = (Contact & {
+    isAdmin?: boolean;
+    isSuperAdmin?: boolean;
+    admin?: 'admin' | 'superadmin' | null;
+    jid?: string;
+    lid?: string;
+});
+export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote' | 'modify';
+export type RequestJoinAction = 'created' | 'revoked' | 'rejected';
+export type RequestJoinMethod = 'invite_link' | 'linked_group_join' | 'non_admin_add' | undefined;
+export interface GroupMetadata {
+    id: string;
+    /** group uses 'lid' or 'pn' to send messages */
+    addressingMode: 'pn' | 'lid';
+    owner: string | undefined;
+    ownerLid?: string | undefined;
+    subject: string;
+    /** group subject owner */
+    subjectOwner?: string;
+    subjectOwnerLid?: string;
+    /** group subject modification date */
+    subjectTime?: number;
+    creation?: number;
+    desc?: string;
+    descOwner?: string;
+    descOwnerLid?: string;
+    descId?: string;
+    descTime?: number;
+    /** if this group is part of a community, it returns the jid of the community to which it belongs */
+    linkedParent?: string;
+    /** is set when the group only allows admins to change group settings */
+    restrict?: boolean;
+    /** is set when the group only allows admins to write messages */
+    announce?: boolean;
+    /** is set when the group also allows members to add participants */
+    memberAddMode?: boolean;
+    /** Request approval to join the group */
+    joinApprovalMode?: boolean;
+    /** is this a community */
+    isCommunity?: boolean;
+    /** is this the announce of a community */
+    isCommunityAnnounce?: boolean;
+    /** number of group participants */
+    size?: number;
+    participants: GroupParticipant[];
+    ephemeralDuration?: number;
+    inviteCode?: string;
+    /** the person who added you to group or changed some setting in group */
+    author?: string;
+}
+export interface WAGroupCreateResponse {
+    status: number;
+    gid?: string;
+    participants?: [{
+        [key: string]: {};
+    }];
+}
+export interface GroupModificationResponse {
+    status: number;
+    participants?: {
+        [key: string]: {};
+    };
+}

package/lib/Types/GroupMetadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });