@skyzopedia/baileys-mod 3.0.2

package/lib/Types/index.js

@@ -0,0 +1,28 @@
+//=======================================================//
+export * from "./GroupMetadata.js";
+export * from "./Newsletter.js";
+export * from "./Contact.js";
+export * from "./Message.js";
+export * from "./Product.js";
+export * from "./Socket.js";
+export * from "./Events.js";
+export * from "./Signal.js";
+export * from "./State.js";
+export * from "./Chat.js";
+export * from "./Call.js";
+export * from "./Auth.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,219 @@
+//=======================================================//
+import { delay, generateRegistrationId } from "./generics.js";
+import { DEFAULT_CACHE_TTLS } from "../Defaults/index.js";
+import { PreKeyManager } from "./pre-key-manager.js";
+import { Curve, signedKeyPair } from "./crypto.js";
+import { AsyncLocalStorage } from "async_hooks";
+import NodeCache from "@cacheable/node-cache";
+import { randomBytes } from "crypto";
+import { Mutex } from "async-mutex";
+import PQueue from "p-queue";
+//=======================================================//
+export function makeCacheableSignalKeyStore(store, logger, _cache) {
+  const cache = _cache ||
+    new NodeCache({
+      stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+      useClones: false,
+      deleteOnExpire: true
+    });
+  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;
+              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?.();
+    }
+  };
+}
+//=======================================================//
+export const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+  const txStorage = new AsyncLocalStorage();
+  const keyQueues = new Map();
+  const txMutexes = new Map();
+  const preKeyManager = new PreKeyManager(state, logger);
+  function getQueue(key) {
+    if (!keyQueues.has(key)) {
+      keyQueues.set(key, new PQueue({ concurrency: 1 }));
+    }
+    return keyQueues.get(key);
+  }
+  function getTxMutex(key) {
+    if (!txMutexes.has(key)) {
+      txMutexes.set(key, new Mutex());
+    }
+    return txMutexes.get(key);
+  }
+  function isInTransaction() {
+    return !!txStorage.getStore();
+  }
+  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) {
+        return state.get(type, ids);
+      }
+      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));
+        ctx.cache[type] = ctx.cache[type] || {};
+        Object.assign(ctx.cache[type], fetched);
+      }
+      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) {
+        const types = Object.keys(data);
+        for (const type_ of types) {
+          const type = type_;
+          if (type === "pre-key") {
+            await preKeyManager.validateDeletions(data, type);
+          }
+        }
+        await Promise.all(types.map(type => getQueue(type).add(async () => {
+          const typeData = { [type]: data[type] };
+          await state.set(typeData);
+        })));
+        return;
+      }
+      logger.trace({ types: Object.keys(data) }, "caching in transaction");
+      for (const key_ in data) {
+        const key = key_;
+        ctx.cache[key] = ctx.cache[key] || {};
+        ctx.mutations[key] = ctx.mutations[key] || {};
+        if (key === "pre-key") {
+          await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true);
+        }
+        else {
+          Object.assign(ctx.cache[key], data[key]);
+          Object.assign(ctx.mutations[key], data[key]);
+        }
+      }
+    },
+    isInTransaction,
+    transaction: async (work, key) => {
+      const existing = txStorage.getStore();
+      if (existing) {
+        logger.trace("reusing existing transaction context");
+        return work();
+      }
+      return getTxMutex(key).runExclusive(async () => {
+        const ctx = {
+          cache: {},
+          mutations: {},
+          dbQueries: 0
+        };
+        logger.trace("entering transaction");
+        try {
+          const result = await txStorage.run(ctx, work);
+          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
+  };
+};
+//=======================================================//

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,44 @@
+//=======================================================//
+import { makeMutex } from "./make-mutex.js";
+import { createInterface } from "readline";
+import { writeFile } from "fs/promises";
+import { delay } from "./generics.js";
+import { createReadStream } from "fs";
+import EventEmitter from "events";
+//=======================================================//
+export const captureEventStream = (ev, filename) => {
+  const oldEmit = ev.emit;
+  const writeMutex = makeMutex();
+  ev.emit = function (...args) {
+    const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + "\n";
+    const result = oldEmit.apply(ev, args);
+    writeMutex.mutex(async () => {
+      await writeFile(filename, content, { flag: "a" });
+    });
+    return result;
+  };
+};
+//=======================================================//
+export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+  const ev = new EventEmitter();
+  const fireEvents = async () => {
+    const fileStream = createReadStream(filename);
+    const rl = createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+      if (line) {
+        const { event, data } = JSON.parse(line);
+        ev.emit(event, data);
+        delayIntervalMs && (await delay(delayIntervalMs));
+      }
+    }
+    fileStream.close();
+  };
+  return {
+    ev,
+    task: fireEvents()
+  };
+};
+//=======================================================//

package/lib/Utils/browser-utils.js

@@ -0,0 +1,17 @@
+//=======================================================//
+import { proto } from "../../WAProto/index.js";
+import { platform, release } from "os";
+//=======================================================//
+const PLATFORM_MAP = {
+  "safari": "Safari"
+};
+//=======================================================//
+export const Browsers = {
+  iOS: (browser) => ["ios", browser, "18.2"]
+};
+//=======================================================//
+export const getPlatformId = (browser) => {
+  const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+  return platformType ? platformType.toString() : "1";
+};
+//=======================================================//

package/lib/Utils/business.js

@@ -0,0 +1,233 @@
+//=======================================================//
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString } from "../WABinary/index.js";
+import { getStream, getUrlFromDirectPath } from "./messages-media.js";
+import { createWriteStream, promises as fs } from "fs";
+import { generateMessageIDV2 } from "./generics.js";
+import { createHash } from "crypto";
+import { Boom } from "@hapi/boom";
+import { tmpdir } from "os";
+import { join } from "path";
+//=======================================================//
+export const parseCatalogNode = (node) => {
+  const catalogNode = getBinaryNodeChild(node, "product_catalog");
+  const products = getBinaryNodeChildren(catalogNode, "product").map(parseProductNode);
+  const paging = getBinaryNodeChild(catalogNode, "paging");
+  return {
+    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,
+      name,
+      products,
+      status: parseStatusInfo(collectionNode)
+    };
+  });
+  return {
+    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
+  };
+  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,
+    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,
+    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
+  };
+  return product;
+};
+//=======================================================//
+export async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
+  product = {
+    ...product,
+    images: product.images
+      ? await uploadingNecessaryImages(product.images, waUploadToServer, timeoutMs)
+      : product.images
+  };
+  return product;
+}
+//=======================================================//
+export const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30000) => {
+  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 };
+      }
+    }
+    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
+    });
+    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"
+  };
+};
+//=======================================================//