@gara31/void-baileys 7.0.0-rc.14

package/lib/Utils/lt-hash.js

@@ -0,0 +1,56 @@
+import { hkdf } from "./crypto.js";
+/**
+ * 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 {
+  constructor(e) {
+    this.salt = e;
+  }
+  async add(e, t) {
+    for (const item of t) {
+      e = await this._addSingle(e, item);
+    }
+    return e;
+  }
+  async subtract(e, t) {
+    for (const item of t) {
+      e = await this._subtractSingle(e, item);
+    }
+    return e;
+  }
+  async subtractThenAdd(e, addList, subtractList) {
+    const subtracted = await this.subtract(e, subtractList);
+    return this.add(subtracted, addList);
+  }
+  async _addSingle(e, t) {
+    const derived = new Uint8Array(
+      await hkdf(Buffer.from(t), o, { info: this.salt }),
+    ).buffer;
+    return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
+  }
+  async _subtractSingle(e, t) {
+    const derived = new Uint8Array(
+      await hkdf(Buffer.from(t), o, { info: this.salt }),
+    ).buffer;
+    return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
+  }
+  performPointwiseWithOverflow(e, t, op) {
+    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");
+//# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.js

@@ -0,0 +1,38 @@
+export const makeMutex = () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let task = Promise.resolve();
+  let taskTimeout;
+  return {
+    mutex(code) {
+      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 const makeKeyedMutex = () => {
+  const map = {};
+  return {
+    mutex(key, task) {
+      if (!map[key]) {
+        map[key] = makeMutex();
+      }
+      return map[key].mutex(task);
+    },
+  };
+};
+//# sourceMappingURL=make-mutex.js.map

package/lib/Utils/message-retry-manager.js

@@ -0,0 +1,181 @@
+import { LRUCache } from "lru-cache";
+/** 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 class MessageRetryManager {
+  constructor(logger, maxMsgRetryCount) {
+    this.logger = logger;
+    this.recentMessagesMap = new LRUCache({
+      max: RECENT_MESSAGES_SIZE,
+      ttl: 5 * 60 * 1000,
+      ttlAutopurge: true,
+      dispose: (_value, key) => {
+        const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
+        if (separatorIndex > -1) {
+          const messageId = key.slice(
+            separatorIndex + MESSAGE_KEY_SEPARATOR.length,
+          );
+          this.messageKeyIndex.delete(messageId);
+        }
+      },
+    });
+    this.messageKeyIndex = new Map();
+    this.sessionRecreateHistory = new LRUCache({
+      ttl: RECREATE_SESSION_TIMEOUT * 2,
+      ttlAutopurge: true,
+    });
+    this.retryCounters = new LRUCache({
+      ttl: 15 * 60 * 1000,
+      ttlAutopurge: true,
+      updateAgeOnGet: true,
+    }); // 15 minutes TTL
+    this.pendingPhoneRequests = {};
+    this.maxMsgRetryCount = 5;
+    this.statistics = {
+      totalRetries: 0,
+      successfulRetries: 0,
+      failedRetries: 0,
+      mediaRetries: 0,
+      sessionRecreations: 0,
+      phoneRequests: 0,
+    };
+    this.maxMsgRetryCount = maxMsgRetryCount;
+  }
+  /**
+   * Add a recent message to the cache for retry handling
+   */
+  addRecentMessage(to, id, message) {
+    const key = { 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, id) {
+    const key = { 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, retryCount, hasSession) {
+    // 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) {
+    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) {
+    return this.retryCounters.get(messageId) || 0;
+  }
+  /**
+   * Check if message has exceeded maximum retry attempts
+   */
+  hasExceededMaxRetries(messageId) {
+    return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
+  }
+  /**
+   * Mark retry as successful
+   */
+  markRetrySuccess(messageId) {
+    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) {
+    this.statistics.failedRetries++;
+    this.retryCounters.delete(messageId);
+    this.cancelPendingPhoneRequest(messageId);
+    this.removeRecentMessage(messageId);
+  }
+  /**
+   * Schedule a phone request with delay
+   */
+  schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+    // 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) {
+    const timeout = this.pendingPhoneRequests[messageId];
+    if (timeout) {
+      clearTimeout(timeout);
+      delete this.pendingPhoneRequests[messageId];
+      this.logger.debug(
+        `Cancelled pending phone request for message ${messageId}`,
+      );
+    }
+  }
+  keyToString(key) {
+    return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
+  }
+  removeRecentMessage(messageId) {
+    const keyStr = this.messageKeyIndex.get(messageId);
+    if (!keyStr) {
+      return;
+    }
+    this.recentMessagesMap.delete(keyStr);
+    this.messageKeyIndex.delete(messageId);
+  }
+}
+//# sourceMappingURL=message-retry-manager.js.map