@nerxa/socketon 0.0.0-stage → 1.21.0

package/src/Utils/tc-token-utils.d.ts

@@ -0,0 +1,29 @@
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export function readTcTokenIndex(keys: any): Promise<any[]>;
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export function buildMergedTcTokenIndexWrite(keys: any, addedJids: any): Promise<{
+    __index: {
+        token: any;
+    };
+}>;
+export function isTcTokenExpired(timestamp: any): boolean;
+export function shouldSendNewTcToken(senderTimestamp: any): boolean;
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export function resolveTcTokenJid(jid: any, getLIDForPN: any): Promise<any>;
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export function resolveIssuanceJid(jid: any, issueToLid: any, getLIDForPN: any, getPNForLID: any): Promise<any>;
+export function buildTcTokenFromJid({ authState, jid, baseContent, getLIDForPN }: {
+    authState: any;
+    jid: any;
+    baseContent?: never[] | undefined;
+    getLIDForPN: any;
+}): Promise<any[] | undefined>;
+export function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }: {
+    result: any;
+    fallbackJid: any;
+    keys: any;
+    getLIDForPN: any;
+    onNewJidStored: any;
+}): Promise<void>;
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY: "__index";

package/src/Utils/tc-token-utils.js

@@ -0,0 +1,155 @@
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false;
+    if (BOT_PHONE_REGEX.test(user))
+        return false;
+    if (isJidMetaAI(jid))
+        return false;
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800;
+const TC_TOKEN_NUM_BUCKETS = 4;
+
+export const TC_TOKEN_INDEX_KEY = '__index';
+
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        const timestamp = entry?.timestamp;
+        if (!tcTokenBuffer?.length || timestamp === undefined || isTcTokenExpired(timestamp)) {
+            if (tcTokenBuffer) {
+
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: { t: String(timestamp) },
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}

package/src/Utils/ttl-cache.d.ts

@@ -0,0 +1,28 @@
+export declare class TTLCache<T = any> {
+    constructor(options?: {
+        /** lifetime in seconds, the same unit node-cache used; 0 or omitted means no expiry */
+        stdTTL?: number;
+        /** ceiling on entries, the oldest is evicted once it is reached */
+        maxKeys?: number;
+        /** alias for maxKeys */
+        max?: number;
+        /** lifetime in milliseconds, takes precedence over stdTTL */
+        ttl?: number;
+    });
+    get(key: string | number): T | undefined;
+    set(key: string | number, value: T, ttl?: number): boolean;
+    has(key: string | number): boolean;
+    del(keys: string | number | Array<string | number>): number;
+    take(key: string | number): T | undefined;
+    mget(keys: Array<string | number>): Record<string, T>;
+    mset(list: Array<{ key: string | number; value?: T; val?: T; ttl?: number }>): boolean;
+    keys(): string[];
+    flushAll(): void;
+    getStats(): { hits: number; misses: number; keys: number; ksize: number; vsize: number };
+    close(): void;
+    on(): this;
+    off(): this;
+    removeAllListeners(): this;
+    readonly size: number;
+}
+export default TTLCache;

package/src/Utils/ttl-cache.js

@@ -0,0 +1,120 @@
+import { LRUCache } from 'lru-cache';
+import { DEFAULT_CACHE_MAX_KEYS } from '../Defaults/index.js';
+
+const asKey = (key) => (typeof key === 'string' ? key : String(key));
+
+const toMilliseconds = (seconds) => {
+    const value = Number(seconds);
+    return Number.isFinite(value) && value > 0 ? Math.round(value * 1000) : 0;
+};
+
+export class TTLCache {
+    #store;
+
+    #ttl;
+
+    #hits = 0;
+
+    #misses = 0;
+
+    constructor({ stdTTL = 0, maxKeys, max, ttl } = {}) {
+        this.#ttl = ttl !== undefined ? Number(ttl) || 0 : toMilliseconds(stdTTL);
+        const limit = Number(max ?? maxKeys);
+        this.#store = new LRUCache({
+            max: Number.isFinite(limit) && limit > 0 ? limit : DEFAULT_CACHE_MAX_KEYS,
+            ...(this.#ttl ? { ttl: this.#ttl } : {})
+        });
+    }
+
+    get(key) {
+        const value = this.#store.get(asKey(key));
+        if (value === undefined) {
+            this.#misses += 1;
+        }
+        else {
+            this.#hits += 1;
+        }
+        return value;
+    }
+
+    set(key, value, ttl) {
+        const override = toMilliseconds(ttl);
+        this.#store.set(asKey(key), value, override ? { ttl: override } : undefined);
+        return true;
+    }
+
+    has(key) {
+        return this.#store.has(asKey(key));
+    }
+
+    del(keys) {
+        const list = Array.isArray(keys) ? keys : [keys];
+        let removed = 0;
+        for (const key of list) {
+            if (this.#store.delete(asKey(key))) {
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+
+    take(key) {
+        const value = this.get(key);
+        this.del(key);
+        return value;
+    }
+
+    mget(keys) {
+        const found = {};
+        for (const key of Array.isArray(keys) ? keys : [keys]) {
+            const value = this.get(key);
+            if (value !== undefined) {
+                found[key] = value;
+            }
+        }
+        return found;
+    }
+
+    mset(list) {
+        for (const item of list ?? []) {
+            this.set(item.key, item.value ?? item.val, item.ttl);
+        }
+        return true;
+    }
+
+    keys() {
+        return [...this.#store.keys()];
+    }
+
+    flushAll() {
+        this.#store.clear();
+        this.#hits = 0;
+        this.#misses = 0;
+    }
+
+    getStats() {
+        return { hits: this.#hits, misses: this.#misses, keys: this.#store.size, ksize: 0, vsize: 0 };
+    }
+
+    close() {
+        this.#store.clear();
+    }
+
+    on() {
+        return this;
+    }
+
+    off() {
+        return this;
+    }
+
+    removeAllListeners() {
+        return this;
+    }
+
+    get size() {
+        return this.#store.size;
+    }
+}
+
+export default TTLCache;

package/src/Utils/use-mongo-auth-state.d.ts

@@ -0,0 +1,21 @@
+export interface MongoAuthStateOptions {
+    collection?: any;
+    db?: any;
+    uri?: string;
+    clientOptions?: any;
+    dbName?: string;
+    collectionName?: string;
+    session?: string;
+}
+export function useMongoAuthState(opts?: MongoAuthStateOptions): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+    clearAuth: () => Promise<void>;
+    close: () => Promise<void>;
+}>;

package/src/Utils/use-mongo-auth-state.js

@@ -0,0 +1,67 @@
+import { loadOptionalModule, makeAuthStateFromStore } from './auth-store.js';
+export async function useMongoAuthState(opts = {}) {
+    const session = opts.session ?? 'default';
+    let collection = opts.collection;
+    let client;
+    if (!collection) {
+        let db = opts.db;
+        if (!db) {
+            if (!opts.uri) {
+                throw new Error('useMongoAuthState needs a collection, a db, or a uri');
+            }
+            const mongodb = await loadOptionalModule('mongodb', 'useMongoAuthState');
+            client = new mongodb.MongoClient(opts.uri, opts.clientOptions);
+            await client.connect();
+            db = client.db(opts.dbName);
+        }
+        collection = db.collection(opts.collectionName ?? 'baileys_auth');
+    }
+    await collection.createIndex({ session: 1, type: 1, id: 1 }, { unique: true });
+    const store = {
+        read: async (type, id) => {
+            const doc = await collection.findOne({ session, type, id });
+            return doc?.value ?? null;
+        },
+        readMany: async (type, ids) => {
+            if (!ids.length) {
+                return {};
+            }
+            const docs = await collection.find({ session, type, id: { $in: ids } }).toArray();
+            const rows = {};
+            for (const doc of docs) {
+                rows[doc.id] = doc.value;
+            }
+            return rows;
+        },
+        write: async (type, id, value) => {
+            await collection.updateOne({ session, type, id }, { $set: { value } }, { upsert: true });
+        },
+        apply: async (writes, removals) => {
+            const operations = [];
+            for (const entry of writes) {
+                operations.push({
+                    updateOne: {
+                        filter: { session, type: entry.type, id: entry.id },
+                        update: { $set: { value: entry.value } },
+                        upsert: true
+                    }
+                });
+            }
+            for (const entry of removals) {
+                operations.push({
+                    deleteOne: {
+                        filter: { session, type: entry.type, id: entry.id }
+                    }
+                });
+            }
+            await collection.bulkWrite(operations, { ordered: false });
+        },
+        clear: async () => {
+            await collection.deleteMany({ session });
+        },
+        close: async () => {
+            await client?.close();
+        }
+    };
+    return makeAuthStateFromStore(store);
+}

package/src/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,11 @@
+export function useMultiFileAuthState(folder: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<any>;
+}>;
+export function countAuthFileLocks(): number;

package/src/Utils/use-multi-file-auth-state.js

@@ -0,0 +1,106 @@
+import { Mutex } from 'async-mutex';
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+
+const fileLocks = new Map();
+
+const withFileLock = async (path, work) => {
+    let entry = fileLocks.get(path);
+    if (!entry) {
+        entry = { mutex: new Mutex(), waiting: 0 };
+        fileLocks.set(path, entry);
+    }
+    entry.waiting++;
+    const release = await entry.mutex.acquire();
+    try {
+        return await work();
+    }
+    finally {
+        release();
+        entry.waiting--;
+        if (entry.waiting === 0) {
+            fileLocks.delete(path);
+        }
+    }
+};
+
+export const countAuthFileLocks = () => fileLocks.size;
+
+export const useMultiFileAuthState = async (folder) => {
+
+    const writeData = async (data, file) => {
+        const filePath = join(folder, fixFileName(file));
+        return withFileLock(filePath, () => writeFile(filePath, JSON.stringify(data, BufferJSON.replacer)));
+    };
+    const readData = async (file) => {
+        try {
+            const filePath = join(folder, fixFileName(file));
+            return await withFileLock(filePath, async () => {
+                const data = await readFile(filePath, { encoding: 'utf-8' });
+                return JSON.parse(data, BufferJSON.reviver);
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            const filePath = join(folder, fixFileName(file));
+            return await withFileLock(filePath, async () => {
+                try {
+                    await unlink(filePath);
+                }
+                catch {
+                }
+            });
+        }
+        catch { }
+    };
+    const folderInfo = await stat(folder).catch(() => { });
+    if (folderInfo) {
+        if (!folderInfo.isDirectory()) {
+            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
+        }
+    }
+    else {
+        await mkdir(folder, { recursive: true });
+    }
+    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
+    const creds = (await readData('creds.json')) || initAuthCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const file = `${category}-${id}.json`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
+    };
+};

package/src/Utils/use-mysql-auth-state.d.ts

@@ -0,0 +1,19 @@
+export interface MySQLAuthStateOptions {
+    pool?: any;
+    uri?: string;
+    config?: any;
+    table?: string;
+    session?: string;
+}
+export function useMySQLAuthState(opts?: MySQLAuthStateOptions): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+    clearAuth: () => Promise<void>;
+    close: () => Promise<void>;
+}>;

package/src/Utils/use-mysql-auth-state.js

@@ -0,0 +1,79 @@
+import { loadOptionalModule, makeAuthStateFromStore } from './auth-store.js';
+const quoteIdentifier = (name) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`table name must be a plain identifier, got ${JSON.stringify(name)}`);
+    }
+    return `\`${name}\``;
+};
+export async function useMySQLAuthState(opts = {}) {
+    const table = quoteIdentifier(opts.table ?? 'baileys_auth');
+    const session = opts.session ?? 'default';
+    let pool = opts.pool;
+    let owned = false;
+    if (!pool) {
+        if (!opts.uri && !opts.config) {
+            throw new Error('useMySQLAuthState needs a pool, a uri, or a config');
+        }
+        const mysql = await loadOptionalModule('mysql2/promise', 'useMySQLAuthState');
+        pool = mysql.createPool(opts.config ?? opts.uri);
+        owned = true;
+    }
+    await pool.query(`CREATE TABLE IF NOT EXISTS ${table} (
+        session VARCHAR(128) NOT NULL,
+        type VARCHAR(128) NOT NULL,
+        id VARCHAR(255) NOT NULL,
+        value LONGTEXT NOT NULL,
+        PRIMARY KEY (session, type, id)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`);
+    const store = {
+        read: async (type, id) => {
+            const [rows] = await pool.query(`SELECT value FROM ${table} WHERE session = ? AND type = ? AND id = ?`, [session, type, id]);
+            return rows[0]?.value ?? null;
+        },
+        readMany: async (type, ids) => {
+            if (!ids.length) {
+                return {};
+            }
+            const [rows] = await pool.query(`SELECT id, value FROM ${table} WHERE session = ? AND type = ? AND id IN (?)`, [session, type, ids]);
+            const found = {};
+            for (const row of rows) {
+                found[row.id] = row.value;
+            }
+            return found;
+        },
+        write: async (type, id, value) => {
+            await pool.query(`INSERT INTO ${table} (session, type, id, value) VALUES (?, ?, ?, ?)
+                ON DUPLICATE KEY UPDATE value = VALUES(value)`, [session, type, id, value]);
+        },
+        apply: async (writes, removals) => {
+            const connection = await pool.getConnection();
+            try {
+                await connection.beginTransaction();
+                for (const entry of writes) {
+                    await connection.query(`INSERT INTO ${table} (session, type, id, value) VALUES (?, ?, ?, ?)
+                        ON DUPLICATE KEY UPDATE value = VALUES(value)`, [session, entry.type, entry.id, entry.value]);
+                }
+                for (const entry of removals) {
+                    await connection.query(`DELETE FROM ${table} WHERE session = ? AND type = ? AND id = ?`, [session, entry.type, entry.id]);
+                }
+                await connection.commit();
+            }
+            catch (err) {
+                await connection.rollback();
+                throw err;
+            }
+            finally {
+                connection.release();
+            }
+        },
+        clear: async () => {
+            await pool.query(`DELETE FROM ${table} WHERE session = ?`, [session]);
+        },
+        close: async () => {
+            if (owned) {
+                await pool.end();
+            }
+        }
+    };
+    return makeAuthStateFromStore(store);
+}

package/src/Utils/use-postgres-auth-state.d.ts

@@ -0,0 +1,19 @@
+export interface PostgresAuthStateOptions {
+    pool?: any;
+    connectionString?: string;
+    config?: any;
+    table?: string;
+    session?: string;
+}
+export function usePostgresAuthState(opts?: PostgresAuthStateOptions): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+    clearAuth: () => Promise<void>;
+    close: () => Promise<void>;
+}>;