gifted-baileys 1.5.6 → 1.5.7

package/lib/Defaults/baileys-version.json

@@ -0,0 +1,3 @@
+{
+    "version": [2, 3000, 1019097045]
+}

package/lib/Defaults/index.d.ts

@@ -0,0 +1,284 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { proto } from '../../WAProto';
+import type { MediaType, SocketConfig } from '../Types';
+export declare const UNAUTHORIZED_CODES: number[];
+export declare const PHONENUMBER_MCC: {
+    "93": number;
+    "355": number;
+    "213": number;
+    "1-684": number;
+    "376": number;
+    "244": number;
+    "1-264": number;
+    "1-268": number;
+    "54": number;
+    "374": number;
+    "297": number;
+    "61": number;
+    "43": number;
+    "994": number;
+    "1-242": number;
+    "973": number;
+    "880": number;
+    "1-246": number;
+    "375": number;
+    "32": number;
+    "501": number;
+    "229": number;
+    "1-441": number;
+    "975": number;
+    "591": number;
+    "387": number;
+    "267": number;
+    "55": number;
+    "1-284": number;
+    "673": number;
+    "359": number;
+    "226": number;
+    "257": number;
+    "855": number;
+    "237": number;
+    "238": number;
+    "1-345": number;
+    "236": number;
+    "235": number;
+    "56": number;
+    "86": number;
+    "57": number;
+    "269": number;
+    "682": number;
+    "506": number;
+    "385": number;
+    "53": number;
+    "357": number;
+    "420": number;
+    "243": number;
+    "45": number;
+    "253": number;
+    "1-767": number;
+    "1-809": number;
+    "1-849": number;
+    "1-829": number;
+    "593": number;
+    "20": number;
+    "503": number;
+    "240": number;
+    "291": number;
+    "372": number;
+    "251": number;
+    "500": number;
+    "298": number;
+    "679": number;
+    "358": number;
+    "33": number;
+    "689": number;
+    "241": number;
+    "220": number;
+    "995": number;
+    "49": number;
+    "233": number;
+    "350": number;
+    "30": number;
+    "299": number;
+    "1-473": number;
+    "1-671": number;
+    "502": number;
+    "224": number;
+    "592": number;
+    "509": number;
+    "504": number;
+    "852": number;
+    "36": number;
+    "354": number;
+    "91": number;
+    "62": number;
+    "98": number;
+    "964": number;
+    "353": number;
+    "972": number;
+    "39": number;
+    "225": number;
+    "1-876": number;
+    "81": number;
+    "962": number;
+    "254": number;
+    "686": number;
+    "383": number;
+    "965": number;
+    "371": number;
+    "961": number;
+    "266": number;
+    "231": number;
+    "218": number;
+    "423": number;
+    "370": number;
+    "352": number;
+    "389": number;
+    "261": number;
+    "265": number;
+    "60": number;
+    "960": number;
+    "223": number;
+    "356": number;
+    "692": number;
+    "222": number;
+    "230": number;
+    "52": number;
+    "691": number;
+    "373": number;
+    "377": number;
+    "976": number;
+    "382": number;
+    "1-664": number;
+    "212": number;
+    "258": number;
+    "95": number;
+    "264": number;
+    "674": number;
+    "977": number;
+    "31": number;
+    "687": number;
+    "64": number;
+    "505": number;
+    "227": number;
+    "234": number;
+    "683": number;
+    "1-670": number;
+    "47": number;
+    "968": number;
+    "92": number;
+    "680": number;
+    "970": number;
+    "507": number;
+    "675": number;
+    "595": number;
+    "51": number;
+    "63": number;
+    "48": number;
+    "351": number;
+    "1-787, 1-939": number;
+    "974": number;
+    "242": number;
+    "40": number;
+    "7": number;
+    "250": number;
+    "290": number;
+    "1-869": number;
+    "1-758": number;
+    "508": number;
+    "1-784": number;
+    "685": number;
+    "378": number;
+    "239": number;
+    "966": number;
+    "221": number;
+    "381": number;
+    "248": number;
+    "232": number;
+    "65": number;
+    "386": number;
+    "677": number;
+    "27": number;
+    "211": number;
+    "34": number;
+    "94": number;
+    "249": number;
+    "597": number;
+    "268": number;
+    "46": number;
+    "41": number;
+    "963": number;
+    "886": number;
+    "992": number;
+    "255": number;
+    "66": number;
+    "228": number;
+    "690": number;
+    "676": number;
+    "1-868": number;
+    "216": number;
+    "90": number;
+    "993": number;
+    "1-649": number;
+    "688": number;
+    "1-340": number;
+    "256": number;
+    "380": number;
+    "971": number;
+    "44": number;
+    "1": number;
+    "598": number;
+    "998": number;
+    "678": number;
+    "379": number;
+    "58": number;
+    "681": number;
+    "967": number;
+    "260": number;
+    "263": number;
+    "670": number;
+    "245": number;
+    "856": number;
+    "599": number;
+    "850": number;
+    "262": number;
+    "82": number;
+    "84": number;
+};
+export declare const DEFAULT_ORIGIN = "https://web.whatsapp.com";
+export declare const MOBILE_ENDPOINT = "g.whatsapp.net";
+export declare const MOBILE_PORT = 443;
+export declare const DEF_CALLBACK_PREFIX = "CB:";
+export declare const DEF_TAG_PREFIX = "TAG:";
+export declare const PHONE_CONNECTION_CB = "CB:Pong";
+export declare const WA_DEFAULT_EPHEMERAL: number;
+export declare const MOBILE_TOKEN: Buffer;
+export declare const MOBILE_REGISTRATION_ENDPOINT = "https://v.whatsapp.net/v2";
+export declare const MOBILE_USERAGENT: string;
+export declare const REGISTRATION_PUBLIC_KEY: Buffer;
+export declare const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+export declare const DICT_VERSION = 2;
+export declare const KEY_BUNDLE_TYPE: Buffer;
+export declare const NOISE_WA_HEADER: Buffer;
+export declare const PROTOCOL_VERSION: number[];
+export declare const MOBILE_NOISE_HEADER: Buffer;
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export declare const URL_REGEX: RegExp;
+export declare const WA_CERT_DETAILS: {
+    SERIAL: number;
+};
+export declare const PROCESSABLE_HISTORY_TYPES: proto.Message.HistorySyncNotification.HistorySyncType[];
+export declare const DEFAULT_CONNECTION_CONFIG: SocketConfig;
+export declare const MEDIA_PATH_MAP: {
+    [T in MediaType]?: string;
+};
+export declare const MEDIA_HKDF_KEY_MAPPING: {
+    audio: string;
+    document: string;
+    gif: string;
+    image: string;
+    ppic: string;
+    product: string;
+    ptt: string;
+    sticker: string;
+    video: string;
+    'thumbnail-document': string;
+    'thumbnail-image': string;
+    'thumbnail-video': string;
+    'thumbnail-link': string;
+    'md-msg-hist': string;
+    'md-app-state': string;
+    'product-catalog-image': string;
+    'payment-bg-image': string;
+    ptv: string;
+};
+export declare const MEDIA_KEYS: ("ppic" | "product" | "image" | "video" | "sticker" | "audio" | "gif" | "ptt" | "thumbnail-document" | "thumbnail-image" | "thumbnail-link" | "thumbnail-video" | "md-app-state" | "md-msg-hist" | "document" | "product-catalog-image" | "payment-bg-image" | "ptv")[];
+export declare const MIN_PREKEY_COUNT = 5;
+export declare const INITIAL_PREKEY_COUNT = 30;
+export declare const DEFAULT_CACHE_TTLS: {
+    SIGNAL_STORE: number;
+    MSG_RETRY: number;
+    CALL_OFFER: number;
+    USER_DEVICES: number;
+};

package/{src → lib}/Defaults/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -53,7 +44,8 @@ exports.PROCESSABLE_HISTORY_TYPES = [
     WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.INITIAL_BOOTSTRAP,
     WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.PUSH_NAME,
     WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.RECENT,
-    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.FULL
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.FULL,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.ON_DEMAND,
 ];
 exports.DEFAULT_CONNECTION_CONFIG = {
     version: baileys_version_json_1.version,
@@ -83,7 +75,8 @@ exports.DEFAULT_CONNECTION_CONFIG = {
         patch: false,
         snapshot: false,
     },
-    getMessage: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+    getMessage: async () => undefined,
+    cachedGroupMetadata: async () => undefined,
     makeSignalRepository: libsignal_1.makeLibSignalRepository
 };
 exports.MEDIA_PATH_MAP = {
@@ -121,8 +114,8 @@ exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP);
 exports.MIN_PREKEY_COUNT = 5;
 exports.INITIAL_PREKEY_COUNT = 30;
 exports.DEFAULT_CACHE_TTLS = {
-    SIGNAL_STORE: 5 * 60, // 5 minutes
-    MSG_RETRY: 60 * 60, // 1 hour
-    CALL_OFFER: 5 * 60, // 5 minutes
+    SIGNAL_STORE: 5 * 60,
+    MSG_RETRY: 60 * 60,
+    CALL_OFFER: 5 * 60,
     USER_DEVICES: 5 * 60, // 5 minutes
 };

package/lib/Signal/libsignal.d.ts

@@ -0,0 +1,3 @@
+import { SignalAuthState } from '../Types';
+import { SignalRepository } from '../Types/Signal';
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;

package/lib/Signal/libsignal.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLibSignalRepository = makeLibSignalRepository;
+const libsignal = __importStar(require("libsignal"));
+const WASignalGroup_1 = require("../../WASignalGroup");
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth);
+    return {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid);
+            const cipher = new WASignalGroup_1.GroupCipher(storage, senderName);
+            return cipher.decrypt(msg);
+        },
+        async processSenderKeyDistributionMessage({ item, authorJid }) {
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
+            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+            }
+            await builder.process(senderName, senderMsg);
+        },
+        async decryptMessage({ jid, type, ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const session = new libsignal.SessionCipher(storage, addr);
+            let result;
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                    break;
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext);
+                    break;
+            }
+            return result;
+        },
+        async encryptMessage({ jid, data }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const cipher = new libsignal.SessionCipher(storage, addr);
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
+        },
+        async encryptGroupMessage({ group, meId, data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId);
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName);
+            const session = new WASignalGroup_1.GroupCipher(storage, senderName);
+            const ciphertext = await session.encrypt(data);
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+            };
+        },
+        async injectE2ESession({ jid, session }) {
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            await cipher.initOutgoing(session);
+        },
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString();
+        },
+    };
+}
+const jidToSignalProtocolAddress = (jid) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
+    return new libsignal.ProtocolAddress(user, device || 0);
+};
+const jidToSignalSenderKeyName = (group, user) => {
+    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString();
+};
+function signalStorage({ creds, keys }) {
+    return {
+        loadSession: async (id) => {
+            const { [id]: sess } = await keys.get('session', [id]);
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess);
+            }
+        },
+        storeSession: async (id, session) => {
+            await keys.set({ 'session': { [id]: session.serialize() } });
+        },
+        isTrustedIdentity: () => {
+            return true;
+        },
+        loadPreKey: async (id) => {
+            const keyId = id.toString();
+            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                };
+            }
+        },
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        loadSignedPreKey: () => {
+            const key = creds.signedPreKey;
+            return {
+                privKey: Buffer.from(key.keyPair.private),
+                pubKey: Buffer.from(key.keyPair.public)
+            };
+        },
+        loadSenderKey: async (keyId) => {
+            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            if (key) {
+                return new WASignalGroup_1.SenderKeyRecord(key);
+            }
+        },
+        storeSenderKey: async (keyId, key) => {
+            await keys.set({ 'sender-key': { [keyId]: key.serialize() } });
+        },
+        getOurRegistrationId: () => (creds.registrationId),
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds;
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public),
+            };
+        }
+    };
+}

package/lib/Socket/Client/abstract-socket-client.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from 'events';
+import { URL } from 'url';
+import { SocketConfig } from '../../Types';
+export declare abstract class AbstractSocketClient extends EventEmitter {
+    url: URL;
+    config: SocketConfig;
+    abstract get isOpen(): boolean;
+    abstract get isClosed(): boolean;
+    abstract get isClosing(): boolean;
+    abstract get isConnecting(): boolean;
+    constructor(url: URL, config: SocketConfig);
+    abstract connect(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './websocket';

package/{src → lib}/Socket/Client/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./abstract-socket-client"), exports);
-__exportStar(require("./mobile-socket-client"), exports);
-__exportStar(require("./web-socket-client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./websocket"), exports);

package/lib/Socket/Client/mobile-socket-client.d.ts

@@ -0,0 +1,12 @@
+import { Socket } from 'net';
+import { AbstractSocketClient } from './abstract-socket-client';
+export declare class MobileSocketClient extends AbstractSocketClient {
+    protected socket: Socket | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get isConnecting(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/mobile-socket-client.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileSocketClient = void 0;
+const net_1 = require("net");
+const abstract_socket_client_1 = require("./abstract-socket-client");
+class MobileSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'open';
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'opening';
+    }
+    async connect() {
+        var _a;
+        if (this.socket) {
+            return;
+        }
+        if (this.config.agent) {
+            throw new Error('There are not support for proxy agent for mobile connection');
+        }
+        else {
+            this.socket = (0, net_1.connect)({
+                host: this.url.hostname,
+                port: Number(this.url.port) || 443
+            });
+        }
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'connect', 'data', 'drain', 'end', 'error', 'lookup', 'ready', 'timeout'];
+        for (const event of events) {
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(event, (...args) => this.emit(event, ...args));
+        }
+        this.socket.on('data', (...args) => this.emit('message', ...args));
+        this.socket.on('ready', (...args) => this.emit('open', ...args));
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        return new Promise(resolve => {
+            this.socket.end(resolve);
+            this.socket = null;
+        });
+    }
+    send(str, cb) {
+        if (this.socket === null) {
+            return false;
+        }
+        return this.socket.write(str, undefined, cb);
+    }
+}
+exports.MobileSocketClient = MobileSocketClient;

package/lib/Socket/Client/types.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { URL } from 'url';
+import { SocketConfig } from '../../Types';
+export declare abstract class AbstractSocketClient extends EventEmitter {
+    url: URL;
+    config: SocketConfig;
+    abstract get isOpen(): boolean;
+    abstract get isClosed(): boolean;
+    abstract get isClosing(): boolean;
+    abstract get isConnecting(): boolean;
+    constructor(url: URL, config: SocketConfig);
+    abstract connect(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient;

package/lib/Socket/Client/websocket.d.ts

@@ -0,0 +1,12 @@
+import WebSocket from 'ws';
+import { AbstractSocketClient } from './types';
+export declare class WebSocketClient extends AbstractSocketClient {
+    protected socket: WebSocket | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get isConnecting(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
+}