@sixcore/baileys 1.0.0

package/src/Utils/logger.ts

@@ -0,0 +1,13 @@
+import P from 'pino'
+
+export interface ILogger {
+	level: string
+	child(obj: Record<string, unknown>): ILogger
+	trace(obj: unknown, msg?: string): void
+	debug(obj: unknown, msg?: string): void
+	info(obj: unknown, msg?: string): void
+	warn(obj: unknown, msg?: string): void
+	error(obj: unknown, msg?: string): void
+}
+
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` })

package/src/Utils/lt-hash.ts

@@ -0,0 +1,65 @@
+import { hkdf } from './crypto'
+
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+const o = 128
+
+class LTHash {
+	salt: string
+
+	constructor(e: string) {
+		this.salt = e
+	}
+
+	async add(e: ArrayBuffer, t: ArrayBuffer[]): Promise<ArrayBuffer> {
+		for (const item of t) {
+			e = await this._addSingle(e, item)
+		}
+
+		return e
+	}
+
+	async subtract(e: ArrayBuffer, t: ArrayBuffer[]): Promise<ArrayBuffer> {
+		for (const item of t) {
+			e = await this._subtractSingle(e, item)
+		}
+
+		return e
+	}
+
+	async subtractThenAdd(e: ArrayBuffer, addList: ArrayBuffer[], subtractList: ArrayBuffer[]): Promise<ArrayBuffer> {
+		const subtracted = await this.subtract(e, subtractList)
+		return this.add(subtracted, addList)
+	}
+
+	private async _addSingle(e: ArrayBuffer, t: ArrayBuffer): Promise<ArrayBuffer> {
+		const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer
+		return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b)
+	}
+
+	private async _subtractSingle(e: ArrayBuffer, t: ArrayBuffer): Promise<ArrayBuffer> {
+		const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer
+		return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b)
+	}
+
+	private performPointwiseWithOverflow(
+		e: ArrayBuffer,
+		t: ArrayBuffer,
+		op: (a: number, b: number) => number
+	): ArrayBuffer {
+		const n = new DataView(e)
+		const i = new DataView(t)
+		const out = new ArrayBuffer(n.byteLength)
+		const s = new DataView(out)
+
+		for (let offset = 0; offset < n.byteLength; offset += 2) {
+			s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true)
+		}
+
+		return out
+	}
+}
+export const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity')

package/src/Utils/make-mutex.ts

@@ -0,0 +1,45 @@
+export const makeMutex = () => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let task = Promise.resolve() as Promise<any>
+
+	let taskTimeout: NodeJS.Timeout | undefined
+
+	return {
+		mutex<T>(code: () => Promise<T> | T): Promise<T> {
+			task = (async () => {
+				// wait for the previous task to complete
+				// if there is an error, we swallow so as to not block the queue
+				try {
+					await task
+				} catch {}
+
+				try {
+					// execute the current task
+					const result = await code()
+					return result
+				} finally {
+					clearTimeout(taskTimeout)
+				}
+			})()
+			// we replace the existing task, appending the new piece of execution to it
+			// so the next task will have to wait for this one to finish
+			return task
+		}
+	}
+}
+
+export type Mutex = ReturnType<typeof makeMutex>
+
+export const makeKeyedMutex = () => {
+	const map: { [id: string]: Mutex } = {}
+
+	return {
+		mutex<T>(key: string, task: () => Promise<T> | T): Promise<T> {
+			if (!map[key]) {
+				map[key] = makeMutex()
+			}
+
+			return map[key].mutex(task)
+		}
+	}
+}

package/src/Utils/message-retry-manager.ts

@@ -0,0 +1,229 @@
+import { LRUCache } from 'lru-cache'
+import type { proto } from '../../WAProto/index.js'
+import type { ILogger } from './logger'
+
+/** Number of sent messages to cache in memory for handling retry receipts */
+const RECENT_MESSAGES_SIZE = 512
+
+const MESSAGE_KEY_SEPARATOR = '\u0000'
+
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000 // 1 hour in milliseconds
+const PHONE_REQUEST_DELAY = 3000
+export interface RecentMessageKey {
+	to: string
+	id: string
+}
+
+export interface RecentMessage {
+	message: proto.IMessage
+	timestamp: number
+}
+
+export interface SessionRecreateHistory {
+	[jid: string]: number // timestamp
+}
+
+export interface RetryCounter {
+	[messageId: string]: number
+}
+
+export type PendingPhoneRequest = Record<string, ReturnType<typeof setTimeout>>
+
+export interface RetryStatistics {
+	totalRetries: number
+	successfulRetries: number
+	failedRetries: number
+	mediaRetries: number
+	sessionRecreations: number
+	phoneRequests: number
+}
+
+export class MessageRetryManager {
+	private recentMessagesMap = new LRUCache<string, RecentMessage>({
+		max: RECENT_MESSAGES_SIZE,
+		ttl: 5 * 60 * 1000,
+		ttlAutopurge: true,
+		dispose: (_value: RecentMessage, key: string) => {
+			const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR)
+			if (separatorIndex > -1) {
+				const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length)
+				this.messageKeyIndex.delete(messageId)
+			}
+		}
+	})
+	private messageKeyIndex = new Map<string, string>()
+	private sessionRecreateHistory = new LRUCache<string, number>({
+		ttl: RECREATE_SESSION_TIMEOUT * 2,
+		ttlAutopurge: true
+	})
+	private retryCounters = new LRUCache<string, number>({
+		ttl: 15 * 60 * 1000,
+		ttlAutopurge: true,
+		updateAgeOnGet: true
+	}) // 15 minutes TTL
+	private pendingPhoneRequests: PendingPhoneRequest = {}
+	private readonly maxMsgRetryCount: number = 5
+	private statistics: RetryStatistics = {
+		totalRetries: 0,
+		successfulRetries: 0,
+		failedRetries: 0,
+		mediaRetries: 0,
+		sessionRecreations: 0,
+		phoneRequests: 0
+	}
+
+	constructor(
+		private logger: ILogger,
+		maxMsgRetryCount: number
+	) {
+		this.maxMsgRetryCount = maxMsgRetryCount
+	}
+
+	/**
+	 * Add a recent message to the cache for retry handling
+	 */
+	addRecentMessage(to: string, id: string, message: proto.IMessage): void {
+		const key: RecentMessageKey = { to, id }
+		const keyStr = this.keyToString(key)
+
+		// Add new message
+		this.recentMessagesMap.set(keyStr, {
+			message,
+			timestamp: Date.now()
+		})
+		this.messageKeyIndex.set(id, keyStr)
+
+		this.logger.debug(`Added message to retry cache: ${to}/${id}`)
+	}
+
+	/**
+	 * Get a recent message from the cache
+	 */
+	getRecentMessage(to: string, id: string): RecentMessage | undefined {
+		const key: RecentMessageKey = { to, id }
+		const keyStr = this.keyToString(key)
+		return this.recentMessagesMap.get(keyStr)
+	}
+
+	/**
+	 * Check if a session should be recreated based on retry count and history
+	 */
+	shouldRecreateSession(jid: string, retryCount: number, hasSession: boolean): { reason: string; recreate: boolean } {
+		// If we don't have a session, always recreate
+		if (!hasSession) {
+			this.sessionRecreateHistory.set(jid, Date.now())
+			this.statistics.sessionRecreations++
+			return {
+				reason: "we don't have a Signal session with them",
+				recreate: true
+			}
+		}
+
+		// Only consider recreation if retry count > 1
+		if (retryCount < 2) {
+			return { reason: '', recreate: false }
+		}
+
+		const now = Date.now()
+		const prevTime = this.sessionRecreateHistory.get(jid)
+
+		// If no previous recreation or it's been more than an hour
+		if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
+			this.sessionRecreateHistory.set(jid, now)
+			this.statistics.sessionRecreations++
+			return {
+				reason: 'retry count > 1 and over an hour since last recreation',
+				recreate: true
+			}
+		}
+
+		return { reason: '', recreate: false }
+	}
+
+	/**
+	 * Increment retry counter for a message
+	 */
+	incrementRetryCount(messageId: string): number {
+		this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1)
+		this.statistics.totalRetries++
+		return this.retryCounters.get(messageId)!
+	}
+
+	/**
+	 * Get retry count for a message
+	 */
+	getRetryCount(messageId: string): number {
+		return this.retryCounters.get(messageId) || 0
+	}
+
+	/**
+	 * Check if message has exceeded maximum retry attempts
+	 */
+	hasExceededMaxRetries(messageId: string): boolean {
+		return this.getRetryCount(messageId) >= this.maxMsgRetryCount
+	}
+
+	/**
+	 * Mark retry as successful
+	 */
+	markRetrySuccess(messageId: string): void {
+		this.statistics.successfulRetries++
+		// Clean up retry counter for successful message
+		this.retryCounters.delete(messageId)
+		this.cancelPendingPhoneRequest(messageId)
+		this.removeRecentMessage(messageId)
+	}
+
+	/**
+	 * Mark retry as failed
+	 */
+	markRetryFailed(messageId: string): void {
+		this.statistics.failedRetries++
+		this.retryCounters.delete(messageId)
+		this.cancelPendingPhoneRequest(messageId)
+		this.removeRecentMessage(messageId)
+	}
+
+	/**
+	 * Schedule a phone request with delay
+	 */
+	schedulePhoneRequest(messageId: string, callback: () => void, delay: number = PHONE_REQUEST_DELAY): void {
+		// Cancel any existing request for this message
+		this.cancelPendingPhoneRequest(messageId)
+
+		this.pendingPhoneRequests[messageId] = setTimeout(() => {
+			delete this.pendingPhoneRequests[messageId]
+			this.statistics.phoneRequests++
+			callback()
+		}, delay)
+
+		this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`)
+	}
+
+	/**
+	 * Cancel pending phone request
+	 */
+	cancelPendingPhoneRequest(messageId: string): void {
+		const timeout = this.pendingPhoneRequests[messageId]
+		if (timeout) {
+			clearTimeout(timeout)
+			delete this.pendingPhoneRequests[messageId]
+			this.logger.debug(`Cancelled pending phone request for message ${messageId}`)
+		}
+	}
+
+	private keyToString(key: RecentMessageKey): string {
+		return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`
+	}
+
+	private removeRecentMessage(messageId: string): void {
+		const keyStr = this.messageKeyIndex.get(messageId)
+		if (!keyStr) {
+			return
+		}
+
+		this.recentMessagesMap.delete(keyStr)
+		this.messageKeyIndex.delete(messageId)
+	}
+}