@gara31/void-baileys 7.0.0-rc.14

package/lib/Types/Auth.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Auth.js.map

package/lib/Types/Bussines.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Bussines.js.map

package/lib/Types/Call.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Call.js.map

package/lib/Types/Chat.js

@@ -0,0 +1,8 @@
+export const ALL_WA_PATCH_NAMES = [
+  "critical_block",
+  "critical_unblock_low",
+  "regular_high",
+  "regular_low",
+  "regular",
+];
+//# sourceMappingURL=Chat.js.map

package/lib/Types/Contact.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Contact.js.map

package/lib/Types/Events.js

@@ -0,0 +1,2 @@
+import { proto } from "../../WAProto/index.js";
+//# sourceMappingURL=Events.js.map

package/lib/Types/GroupMetadata.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=GroupMetadata.js.map

package/lib/Types/Label.js

@@ -0,0 +1,25 @@
+/** WhatsApp has 20 predefined colors */
+export var LabelColor;
+(function (LabelColor) {
+  LabelColor[(LabelColor["Color1"] = 0)] = "Color1";
+  LabelColor[(LabelColor["Color2"] = 1)] = "Color2";
+  LabelColor[(LabelColor["Color3"] = 2)] = "Color3";
+  LabelColor[(LabelColor["Color4"] = 3)] = "Color4";
+  LabelColor[(LabelColor["Color5"] = 4)] = "Color5";
+  LabelColor[(LabelColor["Color6"] = 5)] = "Color6";
+  LabelColor[(LabelColor["Color7"] = 6)] = "Color7";
+  LabelColor[(LabelColor["Color8"] = 7)] = "Color8";
+  LabelColor[(LabelColor["Color9"] = 8)] = "Color9";
+  LabelColor[(LabelColor["Color10"] = 9)] = "Color10";
+  LabelColor[(LabelColor["Color11"] = 10)] = "Color11";
+  LabelColor[(LabelColor["Color12"] = 11)] = "Color12";
+  LabelColor[(LabelColor["Color13"] = 12)] = "Color13";
+  LabelColor[(LabelColor["Color14"] = 13)] = "Color14";
+  LabelColor[(LabelColor["Color15"] = 14)] = "Color15";
+  LabelColor[(LabelColor["Color16"] = 15)] = "Color16";
+  LabelColor[(LabelColor["Color17"] = 16)] = "Color17";
+  LabelColor[(LabelColor["Color18"] = 17)] = "Color18";
+  LabelColor[(LabelColor["Color19"] = 18)] = "Color19";
+  LabelColor[(LabelColor["Color20"] = 19)] = "Color20";
+})(LabelColor || (LabelColor = {}));
+//# sourceMappingURL=Label.js.map

package/lib/Types/LabelAssociation.js

@@ -0,0 +1,7 @@
+/** Association type */
+export var LabelAssociationType;
+(function (LabelAssociationType) {
+  LabelAssociationType["Chat"] = "label_jid";
+  LabelAssociationType["Message"] = "label_message";
+})(LabelAssociationType || (LabelAssociationType = {}));
+//# sourceMappingURL=LabelAssociation.js.map

package/lib/Types/Message.js

@@ -0,0 +1,11 @@
+import { proto } from "../../WAProto/index.js";
+// export the WAMessage Prototypes
+export { proto as WAProto };
+export const WAMessageStubType = proto.WebMessageInfo.StubType;
+export const WAMessageStatus = proto.WebMessageInfo.Status;
+export var WAMessageAddressingMode;
+(function (WAMessageAddressingMode) {
+  WAMessageAddressingMode["PN"] = "pn";
+  WAMessageAddressingMode["LID"] = "lid";
+})(WAMessageAddressingMode || (WAMessageAddressingMode = {}));
+//# sourceMappingURL=Message.js.map

package/lib/Types/Newsletter.js

@@ -0,0 +1,31 @@
+export var XWAPaths;
+(function (XWAPaths) {
+  XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
+  XWAPaths["xwa2_newsletter_subscribers"] = "xwa2_newsletter_subscribers";
+  XWAPaths["xwa2_newsletter_view"] = "xwa2_newsletter_view";
+  XWAPaths["xwa2_newsletter_metadata"] = "xwa2_newsletter";
+  XWAPaths["xwa2_newsletter_admin_count"] = "xwa2_newsletter_admin";
+  XWAPaths["xwa2_newsletter_mute_v2"] = "xwa2_newsletter_mute_v2";
+  XWAPaths["xwa2_newsletter_unmute_v2"] = "xwa2_newsletter_unmute_v2";
+  XWAPaths["xwa2_newsletter_follow"] = "xwa2_newsletter_follow";
+  XWAPaths["xwa2_newsletter_unfollow"] = "xwa2_newsletter_unfollow";
+  XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
+  XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_demote";
+  XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
+})(XWAPaths || (XWAPaths = {}));
+export var QueryIds;
+(function (QueryIds) {
+  QueryIds["CREATE"] = "8823471724422422";
+  QueryIds["UPDATE_METADATA"] = "24250201037901610";
+  QueryIds["METADATA"] = "6563316087068696";
+  QueryIds["SUBSCRIBERS"] = "9783111038412085";
+  QueryIds["FOLLOW"] = "7871414976211147";
+  QueryIds["UNFOLLOW"] = "7238632346214362";
+  QueryIds["MUTE"] = "29766401636284406";
+  QueryIds["UNMUTE"] = "9864994326891137";
+  QueryIds["ADMIN_COUNT"] = "7130823597031706";
+  QueryIds["CHANGE_OWNER"] = "7341777602580933";
+  QueryIds["DEMOTE"] = "6551828931592903";
+  QueryIds["DELETE"] = "30062808666639665";
+})(QueryIds || (QueryIds = {}));
+//# sourceMappingURL=Newsletter.js.map

package/lib/Types/Product.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Product.js.map

package/lib/Types/Signal.js

@@ -0,0 +1,2 @@
+import { proto } from "../../WAProto/index.js";
+//# sourceMappingURL=Signal.js.map

package/lib/Types/Socket.js

@@ -0,0 +1,3 @@
+import { proto } from "../../WAProto/index.js";
+import {} from "./Message.js";
+//# sourceMappingURL=Socket.js.map

package/lib/Types/State.js

@@ -0,0 +1,13 @@
+import { Boom } from "@hapi/boom";
+export var SyncState;
+(function (SyncState) {
+  /** The socket is connecting, but we haven't received pending notifications yet. */
+  SyncState[(SyncState["Connecting"] = 0)] = "Connecting";
+  /** Pending notifications received. Buffering events until we decide whether to sync or not. */
+  SyncState[(SyncState["AwaitingInitialSync"] = 1)] = "AwaitingInitialSync";
+  /** The initial app state sync (history, etc.) is in progress. Buffering continues. */
+  SyncState[(SyncState["Syncing"] = 2)] = "Syncing";
+  /** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
+  SyncState[(SyncState["Online"] = 3)] = "Online";
+})(SyncState || (SyncState = {}));
+//# sourceMappingURL=State.js.map

package/lib/Types/USync.js

@@ -0,0 +1,2 @@
+import { USyncUser } from "../WAUSync/index.js";
+//# sourceMappingURL=USync.js.map

package/lib/Types/index.js

@@ -0,0 +1,32 @@
+export * from "./Auth.js";
+export * from "./GroupMetadata.js";
+export * from "./Chat.js";
+export * from "./Contact.js";
+export * from "./State.js";
+export * from "./Message.js";
+export * from "./Socket.js";
+export * from "./Events.js";
+export * from "./Product.js";
+export * from "./Call.js";
+export * from "./Signal.js";
+export * from "./Newsletter.js";
+export var DisconnectReason;
+(function (DisconnectReason) {
+  DisconnectReason[(DisconnectReason["connectionClosed"] = 428)] =
+    "connectionClosed";
+  DisconnectReason[(DisconnectReason["connectionLost"] = 408)] =
+    "connectionLost";
+  DisconnectReason[(DisconnectReason["connectionReplaced"] = 440)] =
+    "connectionReplaced";
+  DisconnectReason[(DisconnectReason["timedOut"] = 408)] = "timedOut";
+  DisconnectReason[(DisconnectReason["loggedOut"] = 401)] = "loggedOut";
+  DisconnectReason[(DisconnectReason["badSession"] = 500)] = "badSession";
+  DisconnectReason[(DisconnectReason["restartRequired"] = 515)] =
+    "restartRequired";
+  DisconnectReason[(DisconnectReason["multideviceMismatch"] = 411)] =
+    "multideviceMismatch";
+  DisconnectReason[(DisconnectReason["forbidden"] = 403)] = "forbidden";
+  DisconnectReason[(DisconnectReason["unavailableService"] = 503)] =
+    "unavailableService";
+})(DisconnectReason || (DisconnectReason = {}));
+//# sourceMappingURL=index.js.map

package/lib/Utils/auth-utils.js

@@ -0,0 +1,276 @@
+import NodeCache from "@cacheable/node-cache";
+import { AsyncLocalStorage } from "async_hooks";
+import { Mutex } from "async-mutex";
+import { randomBytes } from "crypto";
+import PQueue from "p-queue";
+import { DEFAULT_CACHE_TTLS } from "../Defaults/index.js";
+import { Curve, signedKeyPair } from "./crypto.js";
+import { delay, generateRegistrationId } from "./generics.js";
+import { PreKeyManager } from "./pre-key-manager.js";
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export function makeCacheableSignalKeyStore(store, logger, _cache) {
+  const cache =
+    _cache ||
+    new NodeCache({
+      stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+      useClones: false,
+      deleteOnExpire: true,
+    });
+  // Mutex for protecting cache operations
+  const cacheMutex = new Mutex();
+  function getUniqueId(type, id) {
+    return `${type}.${id}`;
+  }
+  return {
+    async get(type, ids) {
+      return cacheMutex.runExclusive(async () => {
+        const data = {};
+        const idsToFetch = [];
+        for (const id of ids) {
+          const item = await cache.get(getUniqueId(type, id));
+          if (typeof item !== "undefined") {
+            data[id] = item;
+          } else {
+            idsToFetch.push(id);
+          }
+        }
+        if (idsToFetch.length) {
+          logger?.trace({ items: idsToFetch.length }, "loading from store");
+          const fetched = await store.get(type, idsToFetch);
+          for (const id of idsToFetch) {
+            const item = fetched[id];
+            if (item) {
+              data[id] = item;
+              await cache.set(getUniqueId(type, id), item);
+            }
+          }
+        }
+        return data;
+      });
+    },
+    async set(data) {
+      return cacheMutex.runExclusive(async () => {
+        let keys = 0;
+        for (const type in data) {
+          for (const id in data[type]) {
+            await cache.set(getUniqueId(type, id), data[type][id]);
+            keys += 1;
+          }
+        }
+        logger?.trace({ keys }, "updated cache");
+        await store.set(data);
+      });
+    },
+    async clear() {
+      await cache.flushAll();
+      await store.clear?.();
+    },
+  };
+}
+/**
+ * Adds DB-like transaction capability to the SignalKeyStore
+ * Uses AsyncLocalStorage for automatic context management
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export const addTransactionCapability = (
+  state,
+  logger,
+  { maxCommitRetries, delayBetweenTriesMs },
+) => {
+  const txStorage = new AsyncLocalStorage();
+  // Queues for concurrency control
+  const keyQueues = new Map();
+  const txMutexes = new Map();
+  // Pre-key manager for specialized operations
+  const preKeyManager = new PreKeyManager(state, logger);
+  /**
+   * Get or create a queue for a specific key type
+   */
+  function getQueue(key) {
+    if (!keyQueues.has(key)) {
+      keyQueues.set(key, new PQueue({ concurrency: 1 }));
+    }
+    return keyQueues.get(key);
+  }
+  /**
+   * Get or create a transaction mutex
+   */
+  function getTxMutex(key) {
+    if (!txMutexes.has(key)) {
+      txMutexes.set(key, new Mutex());
+    }
+    return txMutexes.get(key);
+  }
+  /**
+   * Check if currently in a transaction
+   */
+  function isInTransaction() {
+    return !!txStorage.getStore();
+  }
+  /**
+   * Commit transaction with retries
+   */
+  async function commitWithRetry(mutations) {
+    if (Object.keys(mutations).length === 0) {
+      logger.trace("no mutations in transaction");
+      return;
+    }
+    logger.trace("committing transaction");
+    for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
+      try {
+        await state.set(mutations);
+        logger.trace(
+          { mutationCount: Object.keys(mutations).length },
+          "committed transaction",
+        );
+        return;
+      } catch (error) {
+        const retriesLeft = maxCommitRetries - attempt - 1;
+        logger.warn(`failed to commit mutations, retries left=${retriesLeft}`);
+        if (retriesLeft === 0) {
+          throw error;
+        }
+        await delay(delayBetweenTriesMs);
+      }
+    }
+  }
+  return {
+    get: async (type, ids) => {
+      const ctx = txStorage.getStore();
+      if (!ctx) {
+        // No transaction - direct read without exclusive lock for concurrency
+        return state.get(type, ids);
+      }
+      // In transaction - check cache first
+      const cached = ctx.cache[type] || {};
+      const missing = ids.filter((id) => !(id in cached));
+      if (missing.length > 0) {
+        ctx.dbQueries++;
+        logger.trace(
+          { type, count: missing.length },
+          "fetching missing keys in transaction",
+        );
+        const fetched = await getTxMutex(type).runExclusive(() =>
+          state.get(type, missing),
+        );
+        // Update cache
+        ctx.cache[type] = ctx.cache[type] || {};
+        Object.assign(ctx.cache[type], fetched);
+      }
+      // Return requested ids from cache
+      const result = {};
+      for (const id of ids) {
+        const value = ctx.cache[type]?.[id];
+        if (value !== undefined && value !== null) {
+          result[id] = value;
+        }
+      }
+      return result;
+    },
+    set: async (data) => {
+      const ctx = txStorage.getStore();
+      if (!ctx) {
+        // No transaction - direct write with queue protection
+        const types = Object.keys(data);
+        // Process pre-keys with validation
+        for (const type_ of types) {
+          const type = type_;
+          if (type === "pre-key") {
+            await preKeyManager.validateDeletions(data, type);
+          }
+        }
+        // Write all data in parallel
+        await Promise.all(
+          types.map((type) =>
+            getQueue(type).add(async () => {
+              const typeData = { [type]: data[type] };
+              await state.set(typeData);
+            }),
+          ),
+        );
+        return;
+      }
+      // In transaction - update cache and mutations
+      logger.trace({ types: Object.keys(data) }, "caching in transaction");
+      for (const key_ in data) {
+        const key = key_;
+        // Ensure structures exist
+        ctx.cache[key] = ctx.cache[key] || {};
+        ctx.mutations[key] = ctx.mutations[key] || {};
+        // Special handling for pre-keys
+        if (key === "pre-key") {
+          await preKeyManager.processOperations(
+            data,
+            key,
+            ctx.cache,
+            ctx.mutations,
+            true,
+          );
+        } else {
+          // Normal key types
+          Object.assign(ctx.cache[key], data[key]);
+          Object.assign(ctx.mutations[key], data[key]);
+        }
+      }
+    },
+    isInTransaction,
+    transaction: async (work, key) => {
+      const existing = txStorage.getStore();
+      // Nested transaction - reuse existing context
+      if (existing) {
+        logger.trace("reusing existing transaction context");
+        return work();
+      }
+      // New transaction - acquire mutex and create context
+      return getTxMutex(key).runExclusive(async () => {
+        const ctx = {
+          cache: {},
+          mutations: {},
+          dbQueries: 0,
+        };
+        logger.trace("entering transaction");
+        try {
+          const result = await txStorage.run(ctx, work);
+          // Commit mutations
+          await commitWithRetry(ctx.mutations);
+          logger.trace({ dbQueries: ctx.dbQueries }, "transaction completed");
+          return result;
+        } catch (error) {
+          logger.error({ error }, "transaction failed, rolling back");
+          throw error;
+        }
+      });
+    },
+  };
+};
+export const initAuthCreds = () => {
+  const identityKey = Curve.generateKeyPair();
+  return {
+    noiseKey: Curve.generateKeyPair(),
+    pairingEphemeralKeyPair: Curve.generateKeyPair(),
+    signedIdentityKey: identityKey,
+    signedPreKey: signedKeyPair(identityKey, 1),
+    registrationId: generateRegistrationId(),
+    advSecretKey: randomBytes(32).toString("base64"),
+    processedHistoryMessages: [],
+    nextPreKeyId: 1,
+    firstUnuploadedPreKeyId: 1,
+    accountSyncCounter: 0,
+    accountSettings: {
+      unarchiveChats: false,
+    },
+    registered: false,
+    pairingCode: undefined,
+    lastPropHash: undefined,
+    routingInfo: undefined,
+    additionalData: undefined,
+  };
+};
+//# sourceMappingURL=auth-utils.js.map

package/lib/Utils/browser-utils.js

@@ -0,0 +1,32 @@
+import { platform, release } from "os";
+import { proto } from "../../WAProto/index.js";
+const PLATFORM_MAP = {
+  aix: "AIX",
+  darwin: "Mac OS",
+  win32: "Windows",
+  android: "Android",
+  freebsd: "FreeBSD",
+  openbsd: "OpenBSD",
+  sunos: "Solaris",
+  linux: undefined,
+  haiku: undefined,
+  cygwin: undefined,
+  netbsd: undefined,
+};
+export const Browsers = {
+  ubuntu: (browser) => ["Ubuntu", browser, "22.04.4"],
+  macOS: (browser) => ["Mac OS", browser, "14.4.1"],
+  baileys: (browser) => ["Baileys", browser, "6.5.0"],
+  windows: (browser) => ["Windows", browser, "10.0.22631"],
+  /** The appropriate browser based on your OS & release */
+  appropriate: (browser) => [
+    PLATFORM_MAP[platform()] || "Ubuntu",
+    browser,
+    release(),
+  ],
+};
+export const getPlatformId = (browser) => {
+  const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+  return platformType ? platformType.toString() : "1"; //chrome
+};
+//# sourceMappingURL=browser-utils.js.map