@sixcore/baileys 1.0.0 → 1.0.2

package/src/Utils/logger.ts

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

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

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

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