@sgintokic/baileys 0.0.2

package/lib/Types/Newsletter.js

@@ -0,0 +1,33 @@
+export var XWAPaths;
+(function (XWAPaths) {
+  XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
+  XWAPaths["xwa2_newsletter_subscribers"] = "xwa2_newsletter_subscribers";
+  XWAPaths["xwa2_newsletter_subscribed"] = "xwa2_newsletter_subscribed";
+  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["JOB_MUTATION"] = "7150902998257522";
+  QueryIds["SUBSCRIBERS"] = "9783111038412085";
+  QueryIds["SUBSCRIBED"] = "6388546374527196";
+  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 = {}));

package/lib/Types/Product.js

@@ -0,0 +1 @@
+export {};

package/lib/Types/Signal.js

@@ -0,0 +1 @@
+import { proto } from "../../WAProto/index.js";

package/lib/Types/Socket.js

@@ -0,0 +1,2 @@
+import { proto } from "../../WAProto/index.js";
+import {} from "./Message.js";

package/lib/Types/State.js

@@ -0,0 +1,15 @@
+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 = {}));

package/lib/Types/USync.js

@@ -0,0 +1 @@
+import { USyncUser } from "../WAUSync/index.js";

package/lib/Types/index.js

@@ -0,0 +1,31 @@
+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 = {}));

package/lib/Utils/auth-utils.js

@@ -0,0 +1,293 @@
+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;
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+              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: 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 (keyed by signal data type - bounded set)
+  const keyQueues = new Map();
+  // Transaction mutexes with reference counting for cleanup
+  const txMutexes = new Map();
+  const txMutexRefCounts = 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());
+      txMutexRefCounts.set(key, 0);
+    }
+    return txMutexes.get(key);
+  }
+  /**
+   * Acquire a reference to a transaction mutex
+   */ function acquireTxMutexRef(key) {
+    const count = txMutexRefCounts.get(key) ?? 0;
+    txMutexRefCounts.set(key, count + 1);
+  }
+  /**
+   * Release a reference to a transaction mutex and cleanup if no longer needed
+   */ function releaseTxMutexRef(key) {
+    const count = (txMutexRefCounts.get(key) ?? 1) - 1;
+    txMutexRefCounts.set(key, count);
+    // Cleanup if no more references and mutex is not locked
+    if (count <= 0) {
+      const mutex = txMutexes.get(key);
+      if (mutex && !mutex.isLocked()) {
+        txMutexes.delete(key);
+        txMutexRefCounts.delete(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: 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: 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
+      const mutex = getTxMutex(key);
+      acquireTxMutexRef(key);
+      try {
+        return await mutex.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: error }, "transaction failed, rolling back");
+            throw error;
+          }
+        });
+      } finally {
+        releaseTxMutexRef(key);
+      }
+    },
+  };
+};
+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,
+  };
+};

package/lib/Utils/browser-utils.js

@@ -0,0 +1,32 @@
+import { platform, release } from "node: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"],
+  android: (browser) => [browser, "Android", ""],
+  /** 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
+};

package/lib/Utils/business.js

@@ -0,0 +1,245 @@
+import { Boom } from "@hapi/boom";
+import { createHash } from "crypto";
+import { createWriteStream, promises as fs } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  getBinaryNodeChild,
+  getBinaryNodeChildren,
+  getBinaryNodeChildString,
+} from "../WABinary/index.js";
+import { generateMessageIDV2 } from "./generics.js";
+import { getStream, getUrlFromDirectPath } from "./messages-media.js";
+export const parseCatalogNode = (node) => {
+  const catalogNode = getBinaryNodeChild(node, "product_catalog");
+  const products = getBinaryNodeChildren(catalogNode, "product").map(
+    parseProductNode,
+  );
+  const paging = getBinaryNodeChild(catalogNode, "paging");
+  return {
+    products: products,
+    nextPageCursor: paging
+      ? getBinaryNodeChildString(paging, "after")
+      : undefined,
+  };
+};
+export const parseCollectionsNode = (node) => {
+  const collectionsNode = getBinaryNodeChild(node, "collections");
+  const collections = getBinaryNodeChildren(collectionsNode, "collection").map(
+    (collectionNode) => {
+      const id = getBinaryNodeChildString(collectionNode, "id");
+      const name = getBinaryNodeChildString(collectionNode, "name");
+      const products = getBinaryNodeChildren(collectionNode, "product").map(
+        parseProductNode,
+      );
+      return {
+        id: id,
+        name: name,
+        products: products,
+        status: parseStatusInfo(collectionNode),
+      };
+    },
+  );
+  return { collections: collections };
+};
+export const parseOrderDetailsNode = (node) => {
+  const orderNode = getBinaryNodeChild(node, "order");
+  const products = getBinaryNodeChildren(orderNode, "product").map(
+    (productNode) => {
+      const imageNode = getBinaryNodeChild(productNode, "image");
+      return {
+        id: getBinaryNodeChildString(productNode, "id"),
+        name: getBinaryNodeChildString(productNode, "name"),
+        imageUrl: getBinaryNodeChildString(imageNode, "url"),
+        price: +getBinaryNodeChildString(productNode, "price"),
+        currency: getBinaryNodeChildString(productNode, "currency"),
+        quantity: +getBinaryNodeChildString(productNode, "quantity"),
+      };
+    },
+  );
+  const priceNode = getBinaryNodeChild(orderNode, "price");
+  const orderDetails = {
+    price: {
+      total: +getBinaryNodeChildString(priceNode, "total"),
+      currency: getBinaryNodeChildString(priceNode, "currency"),
+    },
+    products: products,
+  };
+  return orderDetails;
+};
+export const toProductNode = (productId, product) => {
+  const attrs = {};
+  const content = [];
+  if (typeof productId !== "undefined") {
+    content.push({ tag: "id", attrs: {}, content: Buffer.from(productId) });
+  }
+  if (typeof product.name !== "undefined") {
+    content.push({
+      tag: "name",
+      attrs: {},
+      content: Buffer.from(product.name),
+    });
+  }
+  if (typeof product.description !== "undefined") {
+    content.push({
+      tag: "description",
+      attrs: {},
+      content: Buffer.from(product.description),
+    });
+  }
+  if (typeof product.retailerId !== "undefined") {
+    content.push({
+      tag: "retailer_id",
+      attrs: {},
+      content: Buffer.from(product.retailerId),
+    });
+  }
+  if (product.images.length) {
+    content.push({
+      tag: "media",
+      attrs: {},
+      content: product.images.map((img) => {
+        if (!("url" in img)) {
+          throw new Boom("Expected img for product to already be uploaded", {
+            statusCode: 400,
+          });
+        }
+        return {
+          tag: "image",
+          attrs: {},
+          content: [
+            { tag: "url", attrs: {}, content: Buffer.from(img.url.toString()) },
+          ],
+        };
+      }),
+    });
+  }
+  if (typeof product.price !== "undefined") {
+    content.push({
+      tag: "price",
+      attrs: {},
+      content: Buffer.from(product.price.toString()),
+    });
+  }
+  if (typeof product.currency !== "undefined") {
+    content.push({
+      tag: "currency",
+      attrs: {},
+      content: Buffer.from(product.currency),
+    });
+  }
+  if ("originCountryCode" in product) {
+    if (typeof product.originCountryCode === "undefined") {
+      attrs["compliance_category"] = "COUNTRY_ORIGIN_EXEMPT";
+    } else {
+      content.push({
+        tag: "compliance_info",
+        attrs: {},
+        content: [
+          {
+            tag: "country_code_origin",
+            attrs: {},
+            content: Buffer.from(product.originCountryCode),
+          },
+        ],
+      });
+    }
+  }
+  if (typeof product.isHidden !== "undefined") {
+    attrs["is_hidden"] = product.isHidden.toString();
+  }
+  const node = { tag: "product", attrs: attrs, content: content };
+  return node;
+};
+export const parseProductNode = (productNode) => {
+  const isHidden = productNode.attrs.is_hidden === "true";
+  const id = getBinaryNodeChildString(productNode, "id");
+  const mediaNode = getBinaryNodeChild(productNode, "media");
+  const statusInfoNode = getBinaryNodeChild(productNode, "status_info");
+  const product = {
+    id: id,
+    imageUrls: parseImageUrls(mediaNode),
+    reviewStatus: {
+      whatsapp: getBinaryNodeChildString(statusInfoNode, "status"),
+    },
+    availability: "in stock",
+    name: getBinaryNodeChildString(productNode, "name"),
+    retailerId: getBinaryNodeChildString(productNode, "retailer_id"),
+    url: getBinaryNodeChildString(productNode, "url"),
+    description: getBinaryNodeChildString(productNode, "description"),
+    price: +getBinaryNodeChildString(productNode, "price"),
+    currency: getBinaryNodeChildString(productNode, "currency"),
+    isHidden: isHidden,
+  };
+  return product;
+};
+/**
+ * Uploads images not already uploaded to WA's servers
+ */ export async function uploadingNecessaryImagesOfProduct(
+  product,
+  waUploadToServer,
+  timeoutMs = 3e4,
+) {
+  product = {
+    ...product,
+    images: product.images
+      ? await uploadingNecessaryImages(
+          product.images,
+          waUploadToServer,
+          timeoutMs,
+        )
+      : product.images,
+  };
+  return product;
+}
+/**
+ * Uploads images not already uploaded to WA's servers
+ */ export const uploadingNecessaryImages = async (
+  images,
+  waUploadToServer,
+  timeoutMs = 3e4,
+) => {
+  const results = await Promise.all(
+    images.map(async (img) => {
+      if ("url" in img) {
+        const url = img.url.toString();
+        if (url.includes(".whatsapp.net")) {
+          return { url: url };
+        }
+      }
+      const { stream } = await getStream(img);
+      const hasher = createHash("sha256");
+      const filePath = join(tmpdir(), "img" + generateMessageIDV2());
+      const encFileWriteStream = createWriteStream(filePath);
+      for await (const block of stream) {
+        hasher.update(block);
+        encFileWriteStream.write(block);
+      }
+      const sha = hasher.digest("base64");
+      const { directPath } = await waUploadToServer(filePath, {
+        mediaType: "product-catalog-image",
+        fileEncSha256B64: sha,
+        timeoutMs: timeoutMs,
+      });
+      await fs
+        .unlink(filePath)
+        .catch((err) => console.log("Error deleting temp file ", err));
+      return { url: getUrlFromDirectPath(directPath) };
+    }),
+  );
+  return results;
+};
+const parseImageUrls = (mediaNode) => {
+  const imgNode = getBinaryNodeChild(mediaNode, "image");
+  return {
+    requested: getBinaryNodeChildString(imgNode, "request_image_url"),
+    original: getBinaryNodeChildString(imgNode, "original_image_url"),
+  };
+};
+const parseStatusInfo = (mediaNode) => {
+  const node = getBinaryNodeChild(mediaNode, "status_info");
+  return {
+    status: getBinaryNodeChildString(node, "status"),
+    canAppeal: getBinaryNodeChildString(node, "can_appeal") === "true",
+  };
+};