@codexverified/baileys 2.7.5

package/lib/Socket/username.js

@@ -0,0 +1,229 @@
+import { randomUUID } from 'crypto';
+import { executeWMexQuery } from './mex.js';
+import { USyncQuery, USyncUser } from '../WAUSync/index.js';
+import { makeNewsletterSocket } from './newsletter.js';
+
+/**
+ * w:mex query IDs for username operations.
+ *
+ * Source: whatsapp-android-mex_client_persist_ids.json (WA 2.26.26.4 APK assets)
+ * Cross-checked: live Frida capture on real device (wa-logger-2.26.26.4.js, 2026-06-30)
+ */
+const USERNAME_QUERY_IDS = {
+    CHECK: '26124072630599518', // UsernameCheck
+    CHECK_MULTI: '27134626522840286', // UsernameCheckMulti
+    SET: '27108705368767936', // UsernameSet
+    GET: '32618050064506055', // UsernameGet
+    GET_RECOMMENDATIONS: '26077456248616957', // UsernameGetRecommendationsQuery
+    PIN_SET: '25529696019976770' // UsernamePinSet
+};
+
+/**
+ * Source enum values from EnumC141106Vn (UsernameCheck result)
+ * and EnumC141056Vi (rejection reasons) confirmed via C164057Wg.java
+ */
+const USERNAME_CHECK_RESULT = {
+    SUCCESS: 'SUCCESS',
+    INVALID: 'INVALID'
+};
+
+const USERNAME_SOURCE = {
+    FB: 'FB',
+    IG: 'IG',
+    USER_INPUT: 'USER_INPUT',
+    SUGGESTION: 'SUGGESTION'
+};
+
+export const makeUsernameSocket = (config) => {
+    const sock = makeNewsletterSocket(config);
+    const { query, generateMessageTag, executeUSyncQuery } = sock;
+
+    const mexQuery = (variables, queryId, dataPath) =>
+        executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+
+    /**
+     * Check whether a username is available.
+     *
+     * @param {string} username - The @username to check (without @)
+     * @param {boolean} includeSuggestions - Request alternative suggestions when taken
+     * @returns {object}
+     *   On success:   { available: true, username }
+     *   On taken:     { available: false, username, suggestions: string[], rejectionReasons: string[], suggestionsEligible: boolean }
+     *   On rate-limit: throws Boom with statusCode 429
+     *
+     * Confirmed fields from C164057Wg.java:
+     *   data.xwa2_username_check.result    'SUCCESS' | 'INVALID'
+     *   data.xwa2_username_check.suggestions
+     *   data.xwa2_username_check.rejection_reasons
+     *   data.xwa2_username_check.suggestions_eligible
+     */
+    const checkUsername = async (username, includeSuggestions = true, sessionId) => {
+        // session_id ties this check to the subsequent set step  caller can pass one in
+        // so both use the same UUID (confirmed from live WA 2.26.26.4 capture).
+        const session_id = sessionId || randomUUID();
+        const data = await mexQuery(
+            {
+                username,
+                include_suggestions: includeSuggestions,
+                session_id,
+                source: USERNAME_SOURCE.USER_INPUT
+            },
+            USERNAME_QUERY_IDS.CHECK,
+            'xwa2_username_check'
+        );
+        if (data?.result === USERNAME_CHECK_RESULT.SUCCESS) {
+            return { available: true, username, session_id };
+        }
+        return {
+            available: false,
+            username,
+            session_id,
+            suggestions: data?.suggestions ?? [],
+            rejectionReasons: data?.rejection_reasons ?? [],
+            suggestionsEligible: data?.suggestions_eligible ?? true
+        };
+    };
+
+    /**
+     * Set your own username.
+     *
+     * @param {string} username - The username to set (without @)
+     * @param {object} options
+     *   @param {string} [options.source] - 'USER_INPUT' | 'FB' | 'IG' | 'SUGGESTION'
+     *   @param {string} [options.sessionId] - Optional session tracking ID
+     *   @param {string} [options.pin] - Optional PIN for protected usernames
+     *
+     * Confirmed variables from C1568872p.java A00():
+     *   username, reserved (bool), session_id, source, pin
+     */
+    const setUsername = async (username, options = {}) => {
+        const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options;
+        // session_id links the check and set steps  generate one if caller doesn't supply it.
+        // reserved:true confirmed from live WA 2.26.26.4 capture (was wrongly false before).
+        const session_id = sessionId || randomUUID();
+        const variables = {
+            username,
+            reserved: true,
+            source,
+            session_id,
+            ...(pin ? { pin } : {})
+        };
+        return mexQuery(variables, USERNAME_QUERY_IDS.SET, 'xwa2_username_set');
+    };
+
+    /**
+     * Delete (unset) your own username.
+     *
+     * Confirmed from C1568872p.java:
+     *   str4 = str == null ? "delete" : "set"
+     *    sending username=null triggers the delete path on the server.
+     */
+    const deleteUsername = async () => {
+        return mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete');
+    };
+
+    /**
+     * Get your own current username.
+     *
+     * Confirmed from C1568872p.java A02():
+     *   AbstractC41851rT.A0L(AbstractC130045pa.A0T(), C1363664w.class, "UsernameGet", false)
+     */
+    const getMyUsername = async () => {
+        const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get');
+        return data?.username ?? null;
+    };
+
+    /**
+     * Set or delete the PIN that protects your username.
+     *
+     * @param {string|null} pin - New PIN, or null to delete the PIN
+     *
+     * Confirmed from MexUsernamePinProtocolApi.java:
+     *   operation "UsernamePinSet", variable "pin"
+     *   pin=null triggers the "delete" path on the server.
+     */
+    const setUsernamePin = async (pin) => {
+        // pin=null  delete PIN (server interprets empty/null variables as delete)
+        const variables = pin != null ? { pin } : {};
+        return mexQuery(variables, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set');
+    };
+
+    /**
+     * Look up a contact by their @username via USync.
+     *
+     * Confirmed via USyncContactProtocol.getUserElement():
+     *   { tag: 'contact', attrs: { username, pin? } }
+     *
+     * @param {string} username - The username to look up (without @)
+     * @param {string} [pin] - Optional PIN if the username is PIN-protected
+     * @returns {{ jid, lid?, contact: boolean }|null}
+     */
+    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.
+     * Uses USync with the username protocol.
+     *
+     * @param {...string} jids - One or more JIDs
+     * @returns {Array<{ id, username: string|null }>}
+     */
+    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.
+     * @param {string[]} usernames - Array of usernames (without @)
+     */
+    const checkUsernameMulti = async (usernames) => {
+        const data = await mexQuery(
+            { usernames },
+            USERNAME_QUERY_IDS.CHECK_MULTI,
+            'xwa2_username_check_multi'
+        );
+        return data;
+    };
+
+    /**
+     * Fetch username recommendations for the current user.
+     * @param {string} [source] - Source hint: 'FB' | 'IG' | 'USER_INPUT'
+     */
+    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
+    };
+};

package/lib/Store/index.js

@@ -0,0 +1,4 @@
+export * from './make-cache-manager-store.js';
+export * from './make-in-memory-store.js';
+export * from './make-ordered-dictionary.js';
+export * from './object-repository.js';

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

@@ -0,0 +1,89 @@
+import { createCache } from 'cache-manager';
+import { proto } from '../../WAProto/index.js';
+import { BufferJSON, initAuthCreds } from '../Utils/index.js';
+import logger from '../Utils/logger.js';
+
+/**
+ * Cache-manager backed auth state.
+ *
+ * `store` accepts anything cache-manager v7's createCache({ stores: [...] }) accepts:
+ * a Keyv-compatible store instance (e.g. keyv/redis, keyv/sqlite) or a store factory.
+ * Keys are namespaced under `${sessionKey}:` so multiple sessions can share one store.
+ */
+export const makeCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = file => `${sessionKey}:${file}`;
+    const databaseConn = createCache({ stores: [store], ttl: 0 });
+    const writeData = async (file, data) => {
+        let ttl = undefined;
+        if (file === 'creds') {
+            ttl = 63115200; // 2 years
+        }
+        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 (err) {
+            logger.error({ err }, `Error removing ${file} from session ${sessionKey}`);
+        }
+    };
+    const clearState = async () => {
+        try {
+            // Keyv-compatible stores expose keys(pattern); tolerate stores that don't.
+            const keyed = typeof store?.keys === 'function' ? store : databaseConn;
+            const keys = typeof keyed.keys === 'function' ? await keyed.keys(`${sessionKey}*`) : [];
+            await Promise.all(keys.map(async key => await databaseConn.del(key)));
+        }
+        catch (err) {
+            logger.warn({ err }, 'clearState failed');
+        }
+    };
+    const creds = (await readData('creds')) || initAuthCreds();
+    return {
+        clearState,
+        saveCreds: () => writeData('creds', creds),
+        state: {
+            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);
+                }
+            }
+        }
+    };
+};