gifted-baileys 1.5.0 → 1.5.5

package/src/Signal/libsignal.ts

@@ -0,0 +1,141 @@
+import * as libsignal from 'libsignal'
+import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage, SenderKeyName, SenderKeyRecord } from '../../WASignalGroup'
+import { SignalAuthState } from '../Types'
+import { SignalRepository } from '../Types/Signal'
+import { generateSignalPubKey } from '../Utils'
+import { jidDecode } from '../WABinary'
+
+export function makeLibSignalRepository(auth: SignalAuthState): SignalRepository {
+	const storage = signalStorage(auth)
+	return {
+		decryptGroupMessage({ group, authorJid, msg }) {
+			const senderName = jidToSignalSenderKeyName(group, authorJid)
+			const cipher = new GroupCipher(storage, senderName)
+
+			return cipher.decrypt(msg)
+		},
+		async processSenderKeyDistributionMessage({ item, authorJid }) {
+			const builder = new GroupSessionBuilder(storage)
+			const senderName = jidToSignalSenderKeyName(item.groupId!, authorJid)
+
+			const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
+			const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
+			if(!senderKey) {
+				await storage.storeSenderKey(senderName, new SenderKeyRecord())
+			}
+
+			await builder.process(senderName, senderMsg)
+		},
+		async decryptMessage({ jid, type, ciphertext }) {
+			const addr = jidToSignalProtocolAddress(jid)
+			const session = new libsignal.SessionCipher(storage, addr)
+			let result: Buffer
+			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 GroupSessionBuilder(storage)
+
+			const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
+			if(!senderKey) {
+				await storage.storeSenderKey(senderName, new SenderKeyRecord())
+			}
+
+			const senderKeyDistributionMessage = await builder.create(senderName)
+			const session = new 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: string) => {
+	const { user, device } = jidDecode(jid)!
+	return new libsignal.ProtocolAddress(user, device || 0)
+}
+
+const jidToSignalSenderKeyName = (group: string, user: string): string => {
+	return new SenderKeyName(group, jidToSignalProtocolAddress(user)).toString()
+}
+
+function signalStorage({ creds, keys }: SignalAuthState) {
+	return {
+		loadSession: async(id: string) => {
+			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: number | string) => {
+			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: number) => 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: string) => {
+			const { [keyId]: key } = await keys.get('sender-key', [keyId])
+			if(key) {
+				return new 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: generateSignalPubKey(signedIdentityKey.public),
+			}
+		}
+	}
+}

package/src/Socket/Client/abstract-socket-client.ts

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

package/src/Socket/Client/index.ts

@@ -0,0 +1,3 @@
+export * from './abstract-socket-client'
+export * from './mobile-socket-client'
+export * from './web-socket-client'

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

@@ -0,0 +1,78 @@
+"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());
+    });
+};
+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';
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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));
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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/src/Socket/Client/mobile-socket-client.ts

@@ -0,0 +1,66 @@
+import { connect, Socket } from 'net'
+import { AbstractSocketClient } from './abstract-socket-client'
+
+export class MobileSocketClient extends AbstractSocketClient {
+	protected socket: Socket | null = null
+
+	get isOpen(): boolean {
+		return this.socket?.readyState === 'open'
+	}
+	get isClosed(): boolean {
+		return this.socket === null || this.socket?.readyState === 'closed'
+	}
+	get isClosing(): boolean {
+		return this.socket === null || this.socket?.readyState === 'closed'
+	}
+	get isConnecting(): boolean {
+		return this.socket?.readyState === 'opening'
+	}
+
+	async connect(): Promise<void> {
+		if(this.socket) {
+			return
+		}
+
+		if(this.config.agent) {
+
+			throw new Error('There are not support for proxy agent for mobile connection')
+		} else {
+			this.socket = 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) {
+			this.socket?.on(event, (...args: any[]) => this.emit(event, ...args))
+		}
+
+		this.socket.on('data', (...args: any[]) => this.emit('message', ...args))
+		this.socket.on('ready', (...args: any[]) => this.emit('open', ...args))
+	}
+
+	async close(): Promise<void> {
+		if(!this.socket) {
+			return
+		}
+
+		return new Promise<void>(resolve => {
+			this.socket!.end(resolve)
+			this.socket = null
+		})
+	}
+
+	send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean {
+		if(this.socket === null) {
+			return false
+		}
+
+		return this.socket.write(str, undefined, cb)
+	}
+
+}

package/src/Socket/Client/web-socket-client.js

@@ -0,0 +1,75 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const Defaults_1 = require("../../Defaults");
+const abstract_socket_client_1 = require("./abstract-socket-client");
+class WebSocketClient 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) === ws_1.default.OPEN;
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSED;
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSING;
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CONNECTING;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.socket) {
+                return;
+            }
+            this.socket = new ws_1.default(this.url, {
+                origin: Defaults_1.DEFAULT_ORIGIN,
+                headers: (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers,
+                handshakeTimeout: this.config.connectTimeoutMs,
+                timeout: this.config.connectTimeoutMs,
+                agent: this.config.agent,
+            });
+            this.socket.setMaxListeners(0);
+            const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
+            for (const event of events) {
+                (_b = this.socket) === null || _b === void 0 ? void 0 : _b.on(event, (...args) => this.emit(event, ...args));
+            }
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.socket) {
+                return;
+            }
+            this.socket.close();
+            this.socket = null;
+        });
+    }
+    send(str, cb) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(str, cb);
+        return Boolean(this.socket);
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/src/Socket/Client/web-socket-client.ts

@@ -0,0 +1,57 @@
+import WebSocket from 'ws'
+import { DEFAULT_ORIGIN } from '../../Defaults'
+import { AbstractSocketClient } from './abstract-socket-client'
+
+export class WebSocketClient extends AbstractSocketClient {
+
+	protected socket: WebSocket | null = null
+
+	get isOpen(): boolean {
+		return this.socket?.readyState === WebSocket.OPEN
+	}
+	get isClosed(): boolean {
+		return this.socket === null || this.socket?.readyState === WebSocket.CLOSED
+	}
+	get isClosing(): boolean {
+		return this.socket === null || this.socket?.readyState === WebSocket.CLOSING
+	}
+	get isConnecting(): boolean {
+		return this.socket?.readyState === WebSocket.CONNECTING
+	}
+
+	async connect(): Promise<void> {
+		if(this.socket) {
+			return
+		}
+
+		this.socket = new WebSocket(this.url, {
+			origin: DEFAULT_ORIGIN,
+			headers: this.config.options?.headers as {},
+			handshakeTimeout: this.config.connectTimeoutMs,
+			timeout: this.config.connectTimeoutMs,
+			agent: this.config.agent,
+		})
+
+		this.socket.setMaxListeners(0)
+
+		const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response']
+
+		for(const event of events) {
+			this.socket?.on(event, (...args: any[]) => this.emit(event, ...args))
+		}
+	}
+
+	async close(): Promise<void> {
+		if(!this.socket) {
+			return
+		}
+
+		this.socket.close()
+		this.socket = null
+	}
+	send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean {
+		this.socket?.send(str, cb)
+
+		return Boolean(this.socket)
+	}
+}

package/{lib → src}/Socket/business.js

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeBusinessSocket = void 0;
 const business_1 = require("../Utils/business");
@@ -8,9 +17,9 @@ const messages_recv_1 = require("./messages-recv");
 const makeBusinessSocket = (config) => {
     const sock = (0, messages_recv_1.makeMessagesRecvSocket)(config);
     const { authState, query, waUploadToServer } = sock;
-    const getCatalog = async ({ jid, limit, cursor }) => {
-        var _a;
-        jid = jid || ((_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id);
+    const getCatalog = (_a) => __awaiter(void 0, [_a], void 0, function* ({ jid, limit, cursor }) {
+        var _b;
+        jid = jid || ((_b = authState.creds.me) === null || _b === void 0 ? void 0 : _b.id);
         jid = (0, WABinary_1.jidNormalizedUser)(jid);
         const queryParamNodes = [
             {
@@ -36,7 +45,7 @@ const makeBusinessSocket = (config) => {
                 content: cursor
             });
         }
-        const result = await query({
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -55,12 +64,12 @@ const makeBusinessSocket = (config) => {
             ]
         });
         return (0, business_1.parseCatalogNode)(result);
-    };
-    const getCollections = async (jid, limit = 51) => {
+    });
+    const getCollections = (jid_1, ...args_1) => __awaiter(void 0, [jid_1, ...args_1], void 0, function* (jid, limit = 51) {
         var _a;
         jid = jid || ((_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id);
         jid = (0, WABinary_1.jidNormalizedUser)(jid);
-        const result = await query({
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -100,9 +109,9 @@ const makeBusinessSocket = (config) => {
             ]
         });
         return (0, business_1.parseCollectionsNode)(result);
-    };
-    const getOrderDetails = async (orderId, tokenBase64) => {
-        const result = await query({
+    });
+    const getOrderDetails = (orderId, tokenBase64) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -144,11 +153,11 @@ const makeBusinessSocket = (config) => {
             ]
         });
         return (0, business_1.parseOrderDetailsNode)(result);
-    };
-    const productUpdate = async (productId, update) => {
-        update = await (0, business_1.uploadingNecessaryImagesOfProduct)(update, waUploadToServer);
+    });
+    const productUpdate = (productId, update) => __awaiter(void 0, void 0, void 0, function* () {
+        update = yield (0, business_1.uploadingNecessaryImagesOfProduct)(update, waUploadToServer);
         const editNode = (0, business_1.toProductNode)(productId, update);
-        const result = await query({
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -178,13 +187,13 @@ const makeBusinessSocket = (config) => {
         const productCatalogEditNode = (0, generic_utils_1.getBinaryNodeChild)(result, 'product_catalog_edit');
         const productNode = (0, generic_utils_1.getBinaryNodeChild)(productCatalogEditNode, 'product');
         return (0, business_1.parseProductNode)(productNode);
-    };
-    const productCreate = async (create) => {
+    });
+    const productCreate = (create) => __awaiter(void 0, void 0, void 0, function* () {
         // ensure isHidden is defined
         create.isHidden = !!create.isHidden;
-        create = await (0, business_1.uploadingNecessaryImagesOfProduct)(create, waUploadToServer);
+        create = yield (0, business_1.uploadingNecessaryImagesOfProduct)(create, waUploadToServer);
         const createNode = (0, business_1.toProductNode)(undefined, create);
-        const result = await query({
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -214,9 +223,9 @@ const makeBusinessSocket = (config) => {
         const productCatalogAddNode = (0, generic_utils_1.getBinaryNodeChild)(result, 'product_catalog_add');
         const productNode = (0, generic_utils_1.getBinaryNodeChild)(productCatalogAddNode, 'product');
         return (0, business_1.parseProductNode)(productNode);
-    };
-    const productDelete = async (productIds) => {
-        const result = await query({
+    });
+    const productDelete = (productIds) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield query({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -245,15 +254,12 @@ const makeBusinessSocket = (config) => {
         return {
             deleted: +((productCatalogDelNode === null || productCatalogDelNode === void 0 ? void 0 : productCatalogDelNode.attrs.deleted_count) || 0)
         };
-    };
-    return {
-        ...sock,
-        getOrderDetails,
+    });
+    return Object.assign(Object.assign({}, sock), { logger: config.logger, getOrderDetails,
         getCatalog,
         getCollections,
         productCreate,
         productDelete,
-        productUpdate
-    };
+        productUpdate });
 };
 exports.makeBusinessSocket = makeBusinessSocket;