@aseppxyzz12/baileys 1.1.8

package/lib/Socket/username.js

@@ -0,0 +1,157 @@
+"use strict";
+// Ported & adapted from PouCode fork for AsepXyz Baileys
+// Adds @username support: check availability, set/get/delete your own username,
+// PIN protection, and lookup of contacts by username.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUsernameSocket = exports.USERNAME_SOURCE = exports.USERNAME_CHECK_RESULT = exports.USERNAME_QUERY_IDS = void 0;
+const { executeWMexQuery } = require("./mex");
+const { USyncQuery, USyncUser } = require("../WAUSync");
+const { makeCommunitiesSocket } = require("./community");
+
+/**
+ * w:mex query IDs for username operations.
+ * These numeric IDs are assigned by WhatsApp's Pando/MEX infrastructure.
+ */
+const USERNAME_QUERY_IDS = {
+    CHECK: '26124072630599520',
+    CHECK_MULTI: '27134626522840290',
+    SET: '27108705368767936',
+    GET: '32618050064506056',
+    GET_RECOMMENDATIONS: '26077456248616956',
+    PIN_SET: '25529696019976770'
+};
+exports.USERNAME_QUERY_IDS = USERNAME_QUERY_IDS;
+
+const USERNAME_CHECK_RESULT = {
+    SUCCESS: 'SUCCESS',
+    INVALID: 'INVALID'
+};
+exports.USERNAME_CHECK_RESULT = USERNAME_CHECK_RESULT;
+
+const USERNAME_SOURCE = {
+    FB: 'FB',
+    IG: 'IG',
+    USER_INPUT: 'USER_INPUT',
+    SUGGESTION: 'SUGGESTION'
+};
+exports.USERNAME_SOURCE = USERNAME_SOURCE;
+
+const makeUsernameSocket = (config) => {
+    const sock = makeCommunitiesSocket(config);
+    const { query, generateMessageTag, executeUSyncQuery } = sock;
+
+    const mexQuery = (variables, queryId, dataPath) => executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+
+    /** Check whether a username is available. */
+    const checkUsername = async (username, includeSuggestions = true) => {
+        if (!USERNAME_QUERY_IDS.CHECK) {
+            throw new Error('Username CHECK query_id not configured — capture a live WA session to obtain it');
+        }
+        const data = await mexQuery({ username, include_suggestions: includeSuggestions }, USERNAME_QUERY_IDS.CHECK, 'xwa2_username_check');
+        if (data?.result === USERNAME_CHECK_RESULT.SUCCESS) {
+            return { available: true, username };
+        }
+        return {
+            available: false,
+            username,
+            suggestions: data?.suggestions ?? [],
+            rejectionReasons: data?.rejection_reasons ?? [],
+            suggestionsEligible: data?.suggestions_eligible ?? true
+        };
+    };
+
+    /** Set your own username. */
+    const setUsername = async (username, options = {}) => {
+        if (!USERNAME_QUERY_IDS.SET) {
+            throw new Error('Username SET query_id not configured — capture a live WA session to obtain it');
+        }
+        const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options;
+        const variables = {
+            username,
+            reserved: false,
+            source,
+            ...(sessionId ? { session_id: sessionId } : {}),
+            ...(pin ? { pin } : {})
+        };
+        return mexQuery(variables, USERNAME_QUERY_IDS.SET, 'xwa2_username_set');
+    };
+
+    /** Delete (unset) your own username. */
+    const deleteUsername = async () => {
+        if (!USERNAME_QUERY_IDS.SET) {
+            throw new Error('Username SET query_id not configured — capture a live WA session to obtain it');
+        }
+        return mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete');
+    };
+
+    /** Get your own current username. */
+    const getMyUsername = async () => {
+        if (!USERNAME_QUERY_IDS.GET) {
+            throw new Error('Username GET query_id not configured — capture a live WA session to obtain it');
+        }
+        const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get');
+        return data?.username ?? null;
+    };
+
+    /** Set or delete the PIN that protects your username. */
+    const setUsernamePin = async (pin) => {
+        if (!USERNAME_QUERY_IDS.PIN_SET) {
+            throw new Error('Username PIN_SET query_id not configured — capture a live WA session to obtain it');
+        }
+        return mexQuery({ pin }, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set');
+    };
+
+    /** Look up a contact by their @username via USync. */
+    const findUserByUsername = async (username, pin) => {
+        const usyncQuery = new USyncQuery().withContactProtocol();
+        const user = new USyncUser().withUsername(username);
+        if (pin) user.withUsernameKey(pin);
+        usyncQuery.withUser(user);
+        const result = await executeUSyncQuery(usyncQuery);
+        if (!result?.list?.length) return null;
+        const entry = result.list[0];
+        return {
+            jid: entry.id,
+            contact: entry.contact ?? false
+        };
+    };
+
+    /** Fetch the username of one or more contacts by their JID. */
+    const fetchContactUsernames = async (...jids) => {
+        const usyncQuery = new USyncQuery().withUsernameProtocol();
+        for (const jid of jids) {
+            usyncQuery.withUser(new USyncUser().withId(jid));
+        }
+        const result = await executeUSyncQuery(usyncQuery);
+        return result?.list ?? [];
+    };
+
+    /** Check multiple usernames for availability at once. */
+    const checkUsernameMulti = async (usernames) => {
+        return mexQuery({ usernames }, USERNAME_QUERY_IDS.CHECK_MULTI, 'xwa2_username_check_multi');
+    };
+
+    /** Fetch username recommendations for the current user. */
+    const getUsernameRecommendations = async (source = null) => {
+        const variables = {};
+        if (source) variables.source = source;
+        return mexQuery(variables, USERNAME_QUERY_IDS.GET_RECOMMENDATIONS, 'xwa2_username_get_recommendations');
+    };
+
+    return {
+        ...sock,
+        checkUsername,
+        checkUsernameMulti,
+        setUsername,
+        deleteUsername,
+        getMyUsername,
+        getUsernameRecommendations,
+        setUsernamePin,
+        findUserByUsername,
+        fetchContactUsernames,
+        USERNAME_QUERY_IDS,
+        USERNAME_CHECK_RESULT,
+        USERNAME_SOURCE
+    };
+};
+exports.makeUsernameSocket = makeUsernameSocket;

package/lib/Socket/usync.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUSyncSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const WABinary_1 = require("../WABinary");
+const socket_1 = require("./socket");
+const makeUSyncSocket = (config) => {
+    const sock = (0, socket_1.makeSocket)(config);
+    const { generateMessageTag, query, } = sock;
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+        }
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            };
+        });
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        };
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    return {
+        ...sock,
+        executeUSyncQuery,
+    };
+};
+exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Store/index.js

@@ -0,0 +1,37 @@
+"use strict";
+const __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              let desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+const __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m) {
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) {
+                __createBinding(exports, m, p);
+            }
+        }
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./make-cache-manager-store"), exports);
+__exportStar(require("./make-in-memory-store"), exports);
+__exportStar(require("./make-ordered-dictionary"), exports);
+__exportStar(require("./object-repository"), exports);
+exports.KeyedDB = require("./keyed-db");
+exports.keyedDB = require("./keyed-db");

package/lib/Store/keyed-db.js

@@ -0,0 +1,114 @@
+"use strict";
+// Ported & adapted from PouCode fork for AsepXyz Baileys
+Object.defineProperty(exports, "__esModule", { value: true });
+class KeyedDB {
+    constructor(compareFn, idGetter) {
+        if (typeof compareFn !== "function" || typeof idGetter !== "function") {
+            throw new Error("KeyedDB requires compare and idGetter functions");
+        }
+        this._compare = compareFn;
+        this._idGetter = idGetter;
+        this._array = [];
+        this._dict = {};
+    }
+    get length() {
+        return this._array.length;
+    }
+    get(id) {
+        return this._dict[id];
+    }
+    insert(entry, mode = "insert") {
+        const id = this._idGetter(entry);
+        const existing = this._dict[id];
+        if (existing && mode === "insert") {
+            return false;
+        }
+        this._dict[id] = entry;
+        let inserted = false;
+        for (let i = 0; i < this._array.length; i++) {
+            const cmp = this._compare(this._idGetter(this._array[i]), id);
+            if (cmp < 0) {
+                this._array.splice(i, 0, entry);
+                inserted = true;
+                break;
+            }
+        }
+        if (!inserted) this._array.push(entry);
+        return true;
+    }
+    insertIfAbsent(...entries) {
+        const added = [];
+        for (const entry of entries) {
+            if (!this._dict[this._idGetter(entry)]) {
+                this.insert(entry);
+                added.push(entry);
+            }
+        }
+        return added;
+    }
+    upsert(...entries) {
+        const added = [];
+        for (const entry of entries) {
+            const id = this._idGetter(entry);
+            if (this._dict[id]) {
+                const idx = this._array.findIndex(e => this._idGetter(e) === id);
+                if (idx >= 0) this._array[idx] = entry;
+                this._dict[id] = entry;
+            } else {
+                this.insert(entry);
+                added.push(entry);
+            }
+        }
+        return added;
+    }
+    update(id, updater) {
+        const item = this._dict[id];
+        if (!item) return false;
+        updater(item);
+        const idx = this._array.findIndex(e => this._idGetter(e) === id);
+        if (idx >= 0) this._array[idx] = item;
+        return true;
+    }
+    updateAssign(id, update) {
+        const item = this._dict[id];
+        if (!item) return false;
+        Object.assign(item, update);
+        const idx = this._array.findIndex(e => this._idGetter(e) === id);
+        if (idx >= 0) this._array[idx] = item;
+        return true;
+    }
+    deleteById(id) {
+        if (!this._dict[id]) return false;
+        delete this._dict[id];
+        const idx = this._array.findIndex(e => this._idGetter(e) === id);
+        if (idx >= 0) this._array.splice(idx, 1);
+        return true;
+    }
+    clear() {
+        this._array = [];
+        this._dict = {};
+    }
+    all() {
+        return [...this._array];
+    }
+    filter(predicate) {
+        this._array = this._array.filter(predicate);
+        this._dict = {};
+        for (const entry of this._array) {
+            this._dict[this._idGetter(entry)] = entry;
+        }
+    }
+    count() {
+        return this._array.length;
+    }
+    toJSON() {
+        return this._array;
+    }
+    fromJSON(array) {
+        this.clear();
+        for (const entry of array) this.insert(entry);
+    }
+}
+exports.default = KeyedDB;
+module.exports = KeyedDB;
+module.exports.default = KeyedDB;

package/lib/Store/make-cache-manager-store.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { caching: caching } = require("cache-manager");
+const { proto: proto } = require("../../WAProto");
+const { BufferJSON: BufferJSON, initAuthCreds: initAuthCreds } = require("../Utils");
+const { default: logger } = require("../Utils/logger");
+const makeCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = (file) => `${sessionKey}:${file}`;
+    const databaseConn = await caching(store);
+    const writeData = async (file, data) => {
+        let ttl = undefined;
+        if (file === "creds") {
+            ttl = 63115200;
+        }
+        await databaseConn.set(defaultKey(file), JSON.stringify(data, BufferJSON.replacer), ttl);
+    };
+    const readData = async (file) => {
+        try {
+            const data = await databaseConn.get(defaultKey(file));
+            if (data) {
+                return JSON.parse(data, BufferJSON.reviver);
+            }
+            return null;
+        } catch (error) {
+            logger.error(error);
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            return await databaseConn.del(defaultKey(file));
+        } catch (_a) {
+            logger.error(`Error removing ${file} from session ${sessionKey}`);
+        }
+    };
+    const clearState = async () => {
+        try {
+            const result = await databaseConn.store.keys(`${sessionKey}*`);
+            await Promise.all(result.map(async (key) => await databaseConn.del(key)));
+        } catch (err) {}
+    };
+    const creds = (await readData("creds")) || initAuthCreds();
+    return {
+        clearState: clearState,
+        saveCreds: () => writeData("creds", creds),
+        state: {
+            creds: creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(
+                        ids.map(async (id) => {
+                            let value = await readData(`${type}-${id}`);
+                            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 key = `${category}-${id}`;
+                            tasks.push(value ? writeData(key, value) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                },
+            },
+        },
+    };
+};
+module.exports = { makeCacheManagerAuthState: makeCacheManagerAuthState };