vinnleys 1.0.0

package/lib/Socket/username.js

@@ -0,0 +1,236 @@
+import { executeWMexQuery } from './mex.js'
+import { USyncQuery, USyncUser } from '../WAUSync/index.js'
+import { makeNewsletterSocket } from './newsletter.js'
+import crypto from 'crypto'
+/**
+ * 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 || crypto.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?.includes(USERNAME_CHECK_RESULT.SUCCESS) || 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 || crypto.randomUUID()
+    const variables = {
+      username,
+      reserved: true,
+      source,
+      session_id,
+     ...(pin? { pin } : {})
+    }
+    return mexQuery(variables, USERNAME_QUERY_IDS.SET, 'xwa2_username_set')
+  }
+  
+  const checkAndSetUsername = async (username) => {
+    const r = await checkUsername(username);
+    if (r.available) {
+      return await setUsername(username)
+    }
+    return r
+  }
+
+  /**
+   * 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,10 @@
+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';
+export * from './keyed-db.js';
+export { default as makeCacheManagerStore } from './make-cache-manager-store.js';
+export { default as makeInMemoryStore } from './make-in-memory-store.js';
+export { default as makeOrderedDictionary } from './make-ordered-dictionary.js';
+export { default as objectRepository } from './object-repository.js';
+export { default as keyedDB } from './keyed-db.js';

package/lib/Store/keyed-db.js

@@ -0,0 +1,108 @@
+export default 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);
+    }
+}

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

@@ -0,0 +1,85 @@
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const cacheManager = require("cache-manager");
+
+import * as WAProto_1 from "../../WAProto/index.js";
+import * as Utils_1 from "../Utils/index.js";
+import logger from "../Utils/logger.js";
+
+export default async function makeCacheManagerAuthState(store, sessionKey) {
+    const defaultKey = (file) => `${sessionKey}:${file}`;
+    const databaseConn = await cacheManager.caching(store);
+
+    const writeData = async (file, data) => {
+        let ttl = undefined;
+        if (file === "creds") ttl = 63115200; // 2 years
+        await databaseConn.set(
+            defaultKey(file),
+            JSON.stringify(data, Utils_1.BufferJSON.replacer),
+            ttl
+        );
+    };
+
+    const readData = async (file) => {
+        try {
+            const data = await databaseConn.get(defaultKey(file));
+            if (data) return JSON.parse(data, Utils_1.BufferJSON.reviver);
+            return null;
+        } catch (error) {
+            logger.error(error);
+            return null;
+        }
+    };
+
+    const removeData = async (file) => {
+        try {
+            return await databaseConn.del(defaultKey(file));
+        } catch {
+            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) => databaseConn.del(key)));
+        } catch {}
+    };
+
+    const creds = (await readData("creds")) || Utils_1.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 =
+                                    WAProto_1.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);
+                }
+            }
+        }
+    };
+}

package/lib/Store/make-in-memory-store.js

@@ -0,0 +1,244 @@
+import fs from "fs";
+import * as WAProto_1 from "../../WAProto/index.js";
+import * as Defaults_1 from "../Defaults/index.js";
+import { LabelAssociationType } from "../Types/LabelAssociation.js";
+import * as Utils_1 from "../Utils/index.js";
+import * as WABinary_1 from "../WABinary/index.js";
+import makeOrderedDictionary from "./make-ordered-dictionary.js";
+import { ObjectRepository } from "./object-repository.js";
+import KeyedDB from "./keyed-db.js";
+
+const waChatKey = (pin) => ({
+    key: (c) =>
+        (pin ? (c.pinned ? "1" : "0") : "") +
+        (c.archived ? "0" : "1") +
+        (c.conversationTimestamp
+            ? c.conversationTimestamp.toString(16).padStart(8, "0")
+            : "") +
+        c.id,
+    compare: (k1, k2) => k2.localeCompare(k1)
+});
+
+export const waMessageID = (m) => m.key.id || "";
+
+export const waLabelAssociationKey = {
+    key: (la) =>
+        la.type === LabelAssociationType.Chat
+            ? la.chatId + la.labelId
+            : la.chatId + la.messageId + la.labelId,
+    compare: (k1, k2) => k2.localeCompare(k1)
+};
+
+const makeMessagesDictionary = () => makeOrderedDictionary(waMessageID);
+
+export default function makeInMemoryStore(config) {
+    const socket = config.socket;
+    const chatKey = config.chatKey || waChatKey(true);
+    const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey;
+    const logger =
+        config.logger ||
+        Defaults_1.DEFAULT_CONNECTION_CONFIG.logger.child({
+            stream: "in-mem-store"
+        });
+
+    const chats = new KeyedDB(chatKey.compare, chatKey.key);
+    const messages = {};
+    const contacts = {};
+    const groupMetadata = {};
+    const presences = {};
+    const state = { connection: "close" };
+    const labels = new ObjectRepository();
+    const labelAssociations = new KeyedDB(labelAssociationKey.compare, labelAssociationKey.key);
+
+    const assertMessageList = (jid) => {
+        if (!messages[jid]) messages[jid] = makeMessagesDictionary();
+        return messages[jid];
+    };
+
+    const contactsUpsert = (newContacts) => {
+        const oldContacts = new Set(Object.keys(contacts));
+        for (const contact of newContacts) {
+            oldContacts.delete(contact.id);
+            contacts[contact.id] = { ...(contacts[contact.id] || {}), ...contact };
+        }
+        return oldContacts;
+    };
+
+    const labelsUpsert = (newLabels) => {
+        for (const label of newLabels) labels.upsertById(label.id, label);
+    };
+
+    const bind = (ev) => {
+        ev.on("connection.update", (update) => Object.assign(state, update));
+
+        ev.on("messaging-history.set", ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
+            if (syncType === WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) return;
+            if (isLatest) {
+                chats.clear();
+                for (const id in messages) delete messages[id];
+            }
+            chats.insertIfAbsent(...newChats);
+            const oldContacts = contactsUpsert(newContacts);
+            if (isLatest) for (const jid of oldContacts) delete contacts[jid];
+            for (const msg of newMessages) {
+                const jid = msg.key.remoteJid;
+                const list = assertMessageList(jid);
+                list.upsert(msg, "prepend");
+            }
+        });
+
+        ev.on("contacts.upsert", contactsUpsert);
+
+        ev.on("contacts.update", async (updates) => {
+            for (const update of updates) {
+                const contact = contacts[update.id];
+                if (contact) Object.assign(contact, update);
+            }
+        });
+
+        ev.on("chats.upsert", (newChats) => chats.upsert(...newChats));
+
+        ev.on("chats.update", (updates) => {
+            for (let update of updates) {
+                chats.update(update.id, (chat) => Object.assign(chat, update));
+            }
+        });
+
+        ev.on("labels.edit", (label) => {
+            if (label.deleted) return labels.deleteById(label.id);
+            if (labels.count() < 20) labels.upsertById(label.id, label);
+        });
+
+        ev.on("labels.association", ({ type, association }) => {
+            if (type === "add") labelAssociations.upsert(association);
+            if (type === "remove") labelAssociations.delete(association);
+        });
+
+        ev.on("presence.update", ({ id, presences: update }) => {
+            presences[id] = presences[id] || {};
+            Object.assign(presences[id], update);
+        });
+
+        ev.on("chats.delete", (deletions) => {
+            for (const item of deletions) chats.deleteById(item);
+        });
+
+        ev.on("messages.upsert", ({ messages: newMessages, type }) => {
+            if (type !== "append" && type !== "notify") return;
+            for (const msg of newMessages) {
+                const jid = WABinary_1.jidNormalizedUser(msg.key.remoteJid);
+                const list = assertMessageList(jid);
+                list.upsert(msg, "append");
+                if (type === "notify" && !chats.get(jid))
+                    ev.emit("chats.upsert", [
+                        {
+                            id: jid,
+                            conversationTimestamp: Utils_1.toNumber(msg.messageTimestamp),
+                            unreadCount: 1
+                        }
+                    ]);
+            }
+        });
+
+        ev.on("messages.update", (updates) => {
+            for (const { update, key } of updates) {
+                const list = assertMessageList(WABinary_1.jidNormalizedUser(key.remoteJid));
+                list.updateAssign(key.id, update);
+            }
+        });
+
+        ev.on("messages.delete", (item) => {
+            if ("all" in item) messages[item.jid]?.clear();
+            else {
+                const jid = item.keys[0].remoteJid;
+                const list = messages[jid];
+                if (list) {
+                    const idSet = new Set(item.keys.map((k) => k.id));
+                    list.filter((m) => !idSet.has(m.key.id));
+                }
+            }
+        });
+    };
+
+    const toJSON = () => ({
+        chats,
+        contacts,
+        messages,
+        labels,
+        labelAssociations
+    });
+
+    const fromJSON = (json) => {
+        chats.upsert(...json.chats);
+        labelAssociations.upsert(...(json.labelAssociations || []));
+        contactsUpsert(Object.values(json.contacts));
+        labelsUpsert(Object.values(json.labels || {}));
+        for (const jid in json.messages) {
+            const list = assertMessageList(jid);
+            for (const msg of json.messages[jid])
+                list.upsert(WAProto_1.proto.WebMessageInfo.fromObject(msg), "append");
+        }
+    };
+    const loadMessage = async (jid, id) => {
+        return messages[jid]?.get(id)
+    }
+
+    /**
+     * Persist the whole store to a JSON file on disk (synchronous, atomic write).
+     * Writes to a temp file first then renames, so a crash mid-write can't
+     * corrupt the existing store file.
+     */
+    const writeToFile = (path) => {
+        try {
+            const tmpPath = `${path}.tmp`;
+            fs.writeFileSync(tmpPath, JSON.stringify(toJSON()));
+            fs.renameSync(tmpPath, path);
+        } catch (err) {
+            logger.error({ err }, "failed to write store to file");
+        }
+    };
+
+    /**
+     * Load store state from a JSON file on disk, if it exists.
+     * Safe to call even if the file was never created yet.
+     */
+    const readFromFile = (path) => {
+        if (!fs.existsSync(path)) return;
+        try {
+            const jsonStr = fs.readFileSync(path, { encoding: "utf-8" });
+            const json = JSON.parse(jsonStr);
+            fromJSON(json);
+        } catch (err) {
+            logger.error({ err }, "failed to read store from file");
+        }
+    };
+
+    /**
+     * Convenience helper: load once from `path` (if present), then keep
+     * saving to the same file every `intervalMs` (default 10s).
+     * Returns a function to stop the auto-save interval.
+     */
+    const writeToFileInterval = (path, intervalMs = 10_000) => {
+        readFromFile(path);
+        const interval = setInterval(() => writeToFile(path), intervalMs);
+        return () => clearInterval(interval);
+    };
+
+    return {
+        chats,
+        contacts,
+        messages,
+        groupMetadata,
+        state,
+        presences,
+        labels,
+        labelAssociations,
+        bind,
+        toJSON,
+        fromJSON,
+        loadMessage,
+        writeToFile,
+        readFromFile,
+        writeToFileInterval
+    };
+}