@pontalabs/baileys 1.0.6 → 1.0.8

package/lib/Utils/lt-hash.js

@@ -1,8 +1,58 @@
-import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("./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.
  */
-export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
-//# sourceMappingURL=lt-hash.js.map
+const o = 128
+class d {
+    constructor(e) {
+        this.salt = e
+    }
+    add(e, t) {
+        var r = this
+        for (const item of t) {
+            e = r._addSingle(e, item)
+        }
+        return e
+    }
+    subtract(e, t) {
+        var r = this
+        for (const item of t) {
+            e = r._subtractSingle(e, item)
+        }
+        return e
+    }
+    subtractThenAdd(e, t, r) {
+        var n = this
+        return n.add(n.subtract(e, r), t)
+    }
+    async _addSingle(e, t) {
+        var r = this
+        const n = new Uint8Array(await crypto_1.hkdf(Buffer.from(t), o, { info: r.salt })).buffer
+        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e + t))
+    }
+    async _subtractSingle(e, t) {
+        var r = this
+        const n = new Uint8Array(await crypto_1.hkdf(Buffer.from(t), o, { info: r.salt })).buffer
+        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e - t))
+    }
+    performPointwiseWithOverflow(e, t, r) {
+        const n = new DataView(e), i = new DataView(t), a = new ArrayBuffer(n.byteLength), s = new DataView(a)
+        for (let e = 0; e < n.byteLength; e += 2) {
+            s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0)
+        }
+        return a
+    }
+}
+
+const LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity')
+
+module.exports = {
+  LT_HASH_ANTI_TAMPERING
+}

package/lib/Utils/make-mutex.d.ts

@@ -1,9 +1,9 @@
 export declare const makeMutex: () => {
-    mutex<T>(code: () => Promise<T> | T): Promise<T>;
-};
-export type Mutex = ReturnType<typeof makeMutex>;
+    mutex<T>(code: () => T | Promise<T>): Promise<T>
+}
+
+export type Mutex = ReturnType<typeof makeMutex>
+
 export declare const makeKeyedMutex: () => {
-    mutex<T>(key: string, task: () => Promise<T> | T): Promise<T>;
-};
-export type KeyedMutex = ReturnType<typeof makeKeyedMutex>;
-//# sourceMappingURL=make-mutex.d.ts.map
+    mutex<T>(key: string, task: () => T | Promise<T>): Promise<T>
+}

package/lib/Utils/make-mutex.js

@@ -1,33 +1,49 @@
-import { Mutex as AsyncMutex } from 'async-mutex';
-export const makeMutex = () => {
-    const mutex = new AsyncMutex();
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const makeMutex = () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let task = Promise.resolve()
+    let taskTimeout
     return {
         mutex(code) {
-            return mutex.runExclusive(code);
-        }
-    };
-};
-export const makeKeyedMutex = () => {
-    const map = new Map();
-    return {
-        async mutex(key, task) {
-            let entry = map.get(key);
-            if (!entry) {
-                entry = { mutex: new AsyncMutex(), refCount: 0 };
-                map.set(key, entry);
-            }
-            entry.refCount++;
-            try {
-                return await entry.mutex.runExclusive(task);
-            }
-            finally {
-                entry.refCount--;
-                // only delete it if this is still the current entry
-                if (entry.refCount === 0 && map.get(key) === entry) {
-                    map.delete(key);
+            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 (_a) { }
+                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
+        },
+    }
+}
+
+const makeKeyedMutex = () => {
+    const map = {}
+    return {
+        mutex(key, task) {
+            if (!map[key]) {
+                map[key] = makeMutex()
             }
+            return map[key].mutex(task)
         }
-    };
-};
-//# sourceMappingURL=make-mutex.js.map
+    }
+}
+
+module.exports = {
+  makeMutex, 
+  makeKeyedMutex
+}

package/lib/Utils/message-retry-manager.d.ts

@@ -1,115 +1,88 @@
-import type { proto } from '../../WAProto/index.js';
-import type { ILogger } from './logger.js';
-export interface RecentMessageKey {
-    to: string;
-    id: string;
-}
-export interface RecentMessage {
-    message: proto.IMessage;
-    timestamp: number;
-}
-export interface SessionRecreateHistory {
-    [jid: string]: number;
-}
-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 declare enum RetryReason {
-    UnknownError = 0,
-    SignalErrorNoSession = 1,
-    SignalErrorInvalidKey = 2,
-    SignalErrorInvalidKeyId = 3,
-    /** MAC verification failed - most common cause of decryption failures */
-    SignalErrorInvalidMessage = 4,
-    SignalErrorInvalidSignature = 5,
-    SignalErrorFutureMessage = 6,
-    /** Explicit MAC failure - session is definitely out of sync */
-    SignalErrorBadMac = 7,
-    SignalErrorInvalidSession = 8,
-    SignalErrorInvalidMsgKey = 9,
-    BadBroadcastEphemeralSetting = 10,
-    UnknownCompanionNoPrekey = 11,
-    AdvFailure = 12,
-    StatusRevokeDelay = 13
-}
-export declare class MessageRetryManager {
-    private logger;
-    private recentMessagesMap;
-    private messageKeyIndex;
-    private sessionRecreateHistory;
-    private retryCounters;
-    private baseKeys;
-    private pendingPhoneRequests;
-    private readonly maxMsgRetryCount;
-    private statistics;
-    constructor(logger: ILogger, maxMsgRetryCount: number);
-    /**
-     * Add a recent message to the cache for retry handling
-     */
-    addRecentMessage(to: string, id: string, message: proto.IMessage): void;
-    /**
-     * Get a recent message from the cache
-     */
-    getRecentMessage(to: string, id: string): RecentMessage | undefined;
-    /**
-     * Check if a session should be recreated based on retry count, history, and error code.
-     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
-     */
-    shouldRecreateSession(jid: string, hasSession: boolean, errorCode?: RetryReason): {
-        reason: string;
-        recreate: boolean;
-    };
-    /**
-     * Parse error code from retry receipt's retry node.
-     * Returns undefined if no error code is present.
-     */
-    parseRetryErrorCode(errorAttr: string | undefined): RetryReason | undefined;
-    /**
-     * Check if an error code indicates a MAC failure
-     */
-    isMacError(errorCode: RetryReason | undefined): boolean;
-    /**
-     * Increment retry counter for a message
-     */
-    incrementRetryCount(messageId: string): number;
-    /**
-     * Get retry count for a message
-     */
-    getRetryCount(messageId: string): number;
-    /**
-     * Check if message has exceeded maximum retry attempts
-     */
-    hasExceededMaxRetries(messageId: string): boolean;
-    /**
-     * Mark retry as successful
-     */
-    markRetrySuccess(messageId: string): void;
-    /**
-     * Mark retry as failed
-     */
-    markRetryFailed(messageId: string): void;
-    /**
-     * Schedule a phone request with delay
-     */
-    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void;
-    /**
-     * Cancel pending phone request
-     */
-    cancelPendingPhoneRequest(messageId: string): void;
-    clear(): void;
-    saveBaseKey(addr: string, msgId: string, baseKey: Uint8Array): void;
-    hasSameBaseKey(addr: string, msgId: string, baseKey: Uint8Array): boolean;
-    deleteBaseKey(addr: string, msgId: string): void;
-    private keyToString;
-    private removeRecentMessage;
-}
-//# sourceMappingURL=message-retry-manager.d.ts.map
+import { proto } from '../../WAProto'
+import { ILogger } from './logger'
+
+export interface RecentMessageKey {
+    to: string
+    id: string
+}
+
+export interface RecentMessage {
+    message: proto.IMessage
+    timestamp: number
+}
+
+export interface SessionRecreateHistory {
+    [jid: string]: number
+}
+
+export interface RetryCounter {
+    [messageId: string]: number
+}
+
+export interface PendingPhoneRequest {
+    [messageId: string]: NodeJS.Timeout
+}
+
+export interface RetryStatistics {
+    totalRetries: number
+    successfulRetries: number
+    failedRetries: number
+    mediaRetries: number
+    sessionRecreations: number
+    phoneRequests: number
+}
+
+export declare class MessageRetryManager {
+    private logger
+    private recentMessagesMap
+    private sessionRecreateHistory
+    private retryCounters
+    private pendingPhoneRequests
+    private readonly maxMsgRetryCount
+    private statistics
+    constructor(logger: ILogger, maxMsgRetryCount: number)
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: string, id: string, message: proto.IMessage): void
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: string, id: string): RecentMessage | undefined
+    /**
+     * Check if a session should be recreated based on retry count and history
+     */
+    shouldRecreateSession(jid: string, retryCount: number, hasSession: boolean): {
+        reason: string
+        recreate: boolean
+    }
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: string): number
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: string): number
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: string): boolean
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: string): void
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: string): void
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: string): void
+    private keyToString
+}