socketon 1.31.2-rc → 1.51.17

package/lib/Utils/auth-utils.js

@@ -1,206 +1,219 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initAuthCreds = exports.addTransactionCapability = exports.makeCacheableSignalKeyStore = void 0;
-const crypto_1 = require("crypto");
-const node_cache_1 = __importDefault(require("node-cache"));
-const uuid_1 = require("uuid");
-const Defaults_1 = require("../Defaults");
-const crypto_2 = require("./crypto");
-const generics_1 = require("./generics");
-/**
- * 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
- */
-function makeCacheableSignalKeyStore(store, logger, _cache) {
-    const cache = _cache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
-        useClones: false,
-        deleteOnExpire: true,
+//=======================================================//
+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
     });
-    function getUniqueId(type, id) {
-        return `${type}.${id}`;
-    }
-    return {
-        async get(type, ids) {
-            const data = {};
-            const idsToFetch = [];
-            for (const id of ids) {
-                const item = 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) {
-            let keys = 0;
-            for (const type in data) {
-                for (const id in data[type]) {
-                    cache.set(getUniqueId(type, id), data[type][id]);
-                    keys += 1;
-                }
+  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);
             }
-            logger.trace({ keys }, 'updated cache');
-            await store.set(data);
-        },
-        async clear() {
-            var _a;
-            cache.flushAll();
-            await ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
+          }
+        }
+        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?.();
+    }
+  };
 }
-exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
-/**
- * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
- * this allows batch read & write operations & improves the performance of the lib
- * @param state the key store to apply this capability to
- * @param logger logger to log events
- * @returns SignalKeyStore with transaction capability
- */
-const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
-    // number of queries made to the DB during the transaction
-    // only there for logging purposes
-    let dbQueriesInTransaction = 0;
-    let transactionCache = {};
-    let mutations = {};
-    let transactionsInProgress = 0;
-    return {
-        get: async (type, ids) => {
-            if (isInTransaction()) {
-                const dict = transactionCache[type];
-                const idsRequiringFetch = dict
-                    ? ids.filter(item => typeof dict[item] === 'undefined')
-                    : ids;
-                // only fetch if there are any items to fetch
-                if (idsRequiringFetch.length) {
-                    dbQueriesInTransaction += 1;
-                    const result = await state.get(type, idsRequiringFetch);
-                    transactionCache[type] || (transactionCache[type] = {});
-                    Object.assign(transactionCache[type], result);
-                }
-                return ids.reduce((dict, id) => {
-                    var _a;
-                    const value = (_a = transactionCache[type]) === null || _a === void 0 ? void 0 : _a[id];
-                    if (value) {
-                        dict[id] = value;
-                    }
-                    return dict;
-                }, {});
-            }
-            else {
-                return state.get(type, ids);
-            }
-        },
-        set: data => {
-            if (isInTransaction()) {
-                logger.trace({ types: Object.keys(data) }, 'caching in transaction');
-                for (const key in data) {
-                    transactionCache[key] = transactionCache[key] || {};
-                    Object.assign(transactionCache[key], data[key]);
-                    mutations[key] = mutations[key] || {};
-                    Object.assign(mutations[key], data[key]);
-                }
-            }
-            else {
-                return state.set(data);
-            }
-        },
-        isInTransaction,
-        async transaction(work) {
-            let result;
-            transactionsInProgress += 1;
-            if (transactionsInProgress === 1) {
-                logger.trace('entering transaction');
-            }
-            try {
-                result = await work();
-                // commit if this is the outermost transaction
-                if (transactionsInProgress === 1) {
-                    if (Object.keys(mutations).length) {
-                        logger.trace('committing transaction');
-                        // retry mechanism to ensure we've some recovery
-                        // in case a transaction fails in the first attempt
-                        let tries = maxCommitRetries;
-                        while (tries) {
-                            tries -= 1;
-                            try {
-                                await state.set(mutations);
-                                logger.trace({ dbQueriesInTransaction }, 'committed transaction');
-                                break;
-                            }
-                            catch (error) {
-                                logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
-                                await (0, generics_1.delay)(delayBetweenTriesMs);
-                            }
-                        }
-                    }
-                    else {
-                        logger.trace('no mutations in transaction');
-                    }
-                }
-            }
-            finally {
-                transactionsInProgress -= 1;
-                if (transactionsInProgress === 0) {
-                    transactionCache = {};
-                    mutations = {};
-                    dbQueriesInTransaction = 0;
-                }
-            }
-            return result;
+//=======================================================//
+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;
         }
-    };
-    function isInTransaction() {
-        return transactionsInProgress > 0;
+      });
     }
+  };
 };
-exports.addTransactionCapability = addTransactionCapability;
-const initAuthCreds = () => {
-    const identityKey = crypto_2.Curve.generateKeyPair();
-    return {
-        noiseKey: crypto_2.Curve.generateKeyPair(),
-        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
-        signedIdentityKey: identityKey,
-        signedPreKey: (0, crypto_2.signedKeyPair)(identityKey, 1),
-        registrationId: (0, generics_1.generateRegistrationId)(),
-        advSecretKey: (0, crypto_1.randomBytes)(32).toString('base64'),
-        processedHistoryMessages: [],
-        nextPreKeyId: 1,
-        firstUnuploadedPreKeyId: 1,
-        accountSyncCounter: 0,
-        accountSettings: {
-            unarchiveChats: false
-        },
-        // mobile creds
-        deviceId: Buffer.from((0, uuid_1.v4)().replace(/-/g, ''), 'hex').toString('base64url'),
-        phoneId: (0, uuid_1.v4)(),
-        identityId: (0, crypto_1.randomBytes)(20),
-        registered: false,
-        backupToken: (0, crypto_1.randomBytes)(20),
-        registration: {},
-        pairingCode: undefined,
-        lastPropHash: undefined,
-        routingInfo: undefined,
-    };
+//=======================================================//
+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
+  };
 };
-exports.initAuthCreds = initAuthCreds;
+//=======================================================//

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

@@ -1,63 +1,44 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+//=======================================================//
+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;
+  };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readAndEmitEventStream = exports.captureEventStream = void 0;
-const events_1 = __importDefault(require("events"));
-const fs_1 = require("fs");
-const promises_1 = require("fs/promises");
-const readline_1 = require("readline");
-const generics_1 = require("./generics");
-const make_mutex_1 = require("./make-mutex");
-/**
- * Captures events from a baileys event emitter & stores them in a file
- * @param ev The event emitter to read events from
- * @param filename File to save to
- */
-const captureEventStream = (ev, filename) => {
-    const oldEmit = ev.emit;
-    // write mutex so data is appended in order
-    const writeMutex = (0, make_mutex_1.makeMutex)();
-    // monkey patch eventemitter to capture all events
-    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 (0, promises_1.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()
+  };
 };
-exports.captureEventStream = captureEventStream;
-/**
- * Read event file and emit events from there
- * @param filename filename containing event data
- * @param delayIntervalMs delay between each event emit
- */
-const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
-    const ev = new events_1.default();
-    const fireEvents = async () => {
-        // from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
-        const fileStream = (0, fs_1.createReadStream)(filename);
-        const rl = (0, readline_1.createInterface)({
-            input: fileStream,
-            crlfDelay: Infinity
-        });
-        // Note: we use the crlfDelay option to recognize all instances of CR LF
-        // ('\r\n') in input.txt as a single line break.
-        for await (const line of rl) {
-            if (line) {
-                const { event, data } = JSON.parse(line);
-                ev.emit(event, data);
-                delayIntervalMs && await (0, generics_1.delay)(delayIntervalMs);
-            }
-        }
-        fileStream.close();
-    };
-    return {
-        ev,
-        task: fireEvents()
-    };
-};
-exports.readAndEmitEventStream = readAndEmitEventStream;
+//=======================================================//

package/lib/Utils/browser-utils.js

@@ -0,0 +1,25 @@
+//=======================================================//
+import { proto } from "../../WAProto/index.js";
+import { platform, release } from "os";
+//=======================================================//
+const PLATFORM_MAP = {
+    'Chrome': '49',
+    'Edge': '50',
+    'Firefox': '51',
+    'Opera': '53',
+    'Safari': '54'
+};
+//=======================================================//
+export const Browsers = {
+    iOS: (browser) => ["ios", browser, "18.2"], 
+    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']
+};
+//=======================================================//
+export const getPlatformId = (browser) => {
+  const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+  return platformType ? platformType.toString() : "1";
+};
+//=======================================================//