@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/Socket/spam-report.js

@@ -0,0 +1,65 @@
+import { createReportingInfoStore } from '../Store/index.js'
+import { SPAM_FLOWS, resolveReportJid, normalizeReportingTag, buildSpamReportIq, buildSimpleReportNode, parseSpamReportResponse } from '../Utils/index.js'
+import { isJidGroup, isPnUser, isLidUser, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js'
+
+export const makeSpamReportSocket = (sock, config) => {
+    const { query, signalRepository, updateBlockStatus, logger } = sock
+
+    if (!config.reportingInfoStore) config.reportingInfoStore = createReportingInfoStore()
+    const store = config.reportingInfoStore
+
+    const simpleReportQuery = (jid, messageKeys) => query({
+        tag: 'iq',
+        attrs: { type: 'set', xmlns: 'spam', to: S_WHATSAPP_NET },
+        content: [buildSimpleReportNode(jid, messageKeys)]
+    })
+
+    const reportSpam = async (jid, options = {}) => {
+        const { spamFlow = SPAM_FLOWS.ACCOUNT_INFO_REPORT, messages: manualMessages, maxMessages = 5 } = options
+        const reportJid = await resolveReportJid(jid, signalRepository?.lidMapping)
+        let messages = manualMessages
+        if (!messages?.length) {
+            messages = store.getForJid(reportJid, maxMessages)
+            if (!messages.length) messages = store.getForJid(jid, maxMessages)
+        }
+        if (!messages?.length) throw new Error(`reportSpam: no reporting_tag stored for ${jid}. Receive at least one message first.`)
+        const normalized = messages.slice(0, maxMessages).map(m => ({
+            stanzaId: m.stanzaId || m.id,
+            timestamp: Number(m.timestamp || m.sendTimestamp || m.t),
+            reportingTag: normalizeReportingTag(m.reportingTag || m.tag),
+            text: m.text ?? m.raw ?? '',
+            pushName: m.pushName || m.reportedPushName || '',
+            messageType: m.messageType || m.type || 'text',
+            fromJid: m.fromJid || m.from || reportJid
+        }))
+        logger?.debug?.({ jid: reportJid, spamFlow, count: normalized.length }, 'sending spam report IQ')
+        const result = await query(buildSpamReportIq(reportJid, normalized, spamFlow))
+        return { ...parseSpamReportResponse(result), messageCount: normalized.length }
+    }
+
+    const reportContact = async (jid, messageKeys = []) => {
+        const normalized = jidNormalizedUser(jid)
+        if (!isPnUser(normalized) && !isLidUser(normalized)) throw new Error('reportContact requires a valid contact JID')
+        const result = await simpleReportQuery(normalized, messageKeys)
+        await updateBlockStatus(normalized, 'block')
+        return parseSpamReportResponse(result)
+    }
+
+    const reportGroup = async (jid, messageKeys = []) => {
+        if (!isJidGroup(jid)) throw new Error('reportGroup requires a valid group JID')
+        const result = await simpleReportQuery(jid, messageKeys)
+        await query({ tag: 'iq', attrs: { type: 'set', xmlns: 'w:g2', to: '@g.us' }, content: [{ tag: 'leave', attrs: {}, content: [{ tag: 'group', attrs: { id: jid } }] }] })
+        return parseSpamReportResponse(result)
+    }
+
+    return {
+        ...sock,
+        reportSpam,
+        reportContact,
+        reportGroup,
+        getStoredReportingInfo: (jid, max = 5) => store.getForJid(jid, max),
+        clearStoredReportingInfo: jid => store.clear(jid),
+        reportingInfoStore: store,
+        SPAM_FLOWS
+    }
+}

package/lib/Socket/username.js

@@ -0,0 +1,82 @@
+import { randomUUID } from 'crypto';
+import { executeWMexQuery } from './mex.js';
+import { USyncQuery, USyncUser } from '../WAUSync/index.js';
+import { makeRegistrationSocket } from './registration.js';
+import { makeSpamReportSocket } from './spam-report.js';
+import { USERNAME_QUERY_IDS, USERNAME_CHECK_RESULT, USERNAME_SOURCE } from '../Defaults/index.js';
+
+export const makeUsernameSocket = config => {
+    const sock = makeRegistrationSocket(config);
+    const { query, generateMessageTag, executeUSyncQuery } = sock;
+
+    const mexQuery = (variables, queryId, dataPath) => executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+
+    const checkUsername = async (username, includeSuggestions = true, sessionId) => {
+        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 };
+    };
+
+    const setUsername = async (username, options = {}) => {
+        const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options;
+        const session_id = sessionId || randomUUID();
+        return mexQuery({ username, reserved: true, source, session_id, ...(pin ? { pin } : {}) }, USERNAME_QUERY_IDS.SET, 'xwa2_username_set');
+    };
+
+    const checkAndSetUsername = async username => {
+        const r = await checkUsername(username);
+        if (r.available) return setUsername(username);
+        return r;
+    };
+
+    const deleteUsername = async () => mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete');
+
+    const getMyUsername = async () => {
+        const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get');
+        return data?.username ?? null;
+    };
+
+    const setUsernamePin = async pin => mexQuery(pin != null ? { pin } : {}, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set');
+
+    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 };
+    };
+
+    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 ?? [];
+    };
+
+    const checkUsernameMulti = async usernames => mexQuery({ usernames }, USERNAME_QUERY_IDS.CHECK_MULTI, 'xwa2_username_check_multi');
+
+    const getUsernameRecommendations = async (source = null) => mexQuery(source ? { source } : {}, USERNAME_QUERY_IDS.GET_RECOMMENDATIONS, 'xwa2_username_get_recommendations');
+
+    const base = {
+        ...sock,
+        checkUsername,
+        checkUsernameMulti,
+        setUsername,
+        checkAndSetUsername,
+        deleteUsername,
+        getMyUsername,
+        getUsernameRecommendations,
+        setUsernamePin,
+        findUserByUsername,
+        fetchContactUsernames,
+        USERNAME_QUERY_IDS,
+        USERNAME_CHECK_RESULT,
+        USERNAME_SOURCE
+    };
+
+    return makeSpamReportSocket(base, config);
+};

package/lib/Store/index.js

@@ -0,0 +1,6 @@
+export * from './make-cache-manager-store.js'
+export * from './make-in-memory-store.js'
+export * from './make-ordered-dictionary.js'
+export * from './reporting-info-store.js'
+export { makeInMemoryStore as default } from './make-in-memory-store.js'
+export * from './object-repository.js'

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

@@ -0,0 +1,81 @@
+import * as cacheManager from 'cache-manager';
+import * as WAProto from '../../WAProto/index.js';
+import { BufferJSON, initAuthCreds } from '../Utils/index.js';
+import logger from '../Utils/logger.js';
+
+const makeCacheManagerAuthState = async (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, 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 {
+      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 {}
+  };
+
+  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 = WAProto.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);
+        },
+      },
+    },
+  };
+};
+
+export { makeCacheManagerAuthState };

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

@@ -0,0 +1,425 @@
+import WAProto from '../../WAProto/index.js';
+import * as Defaults 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';
+
+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)
+});
+
+const waMessageID = (m) => m.key.id || '';
+
+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);
+
+const makeInMemoryStore = (config) => {
+    const socket = config.socket
+    const chatKey = config.chatKey || waChatKey(true)
+    const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey
+    const logger = config.logger || Defaults.DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' })
+    const KeyedDB = require('@adiwajshing/keyed-db').default
+    const chats = new KeyedDB(chatKey, c => c.id)
+    const messages = {}
+    const contacts = {}
+    const groupMetadata = {}
+    const presences = {}
+    const state = { connection: 'close' }
+    const labels = new ObjectRepository()
+    const labelAssociations = new KeyedDB(labelAssociationKey, 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] = Object.assign(contacts[contact.id] || {}, contact)
+        }
+        return oldContacts
+    }
+    const labelsUpsert = (newLabels) => {
+        for (const label of newLabels) {
+            labels.upsertById(label.id, label)
+        }
+    }
+    /**
+     * binds to a BaileysEventEmitter.
+     * It listens to all events and constructs a state that you can query accurate data from.
+     * Eg. can use the store to fetch chats, contacts, messages etc.
+     * @param ev typically the event emitter from the socket connection
+     */
+    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.proto.HistorySync.HistorySyncType.ON_DEMAND) {
+                return // FOR NOW,
+                //TODO: HANDLE
+            }
+            if (isLatest) {
+                chats.clear()
+                for (const id in messages) {
+                    delete messages[id]
+                }
+            }
+            const chatsAdded = chats.insertIfAbsent(...newChats).length
+            logger.debug({ chatsAdded }, 'synced chats')
+            const oldContacts = contactsUpsert(newContacts)
+            if (isLatest) {
+                for (const jid of oldContacts) {
+                    delete contacts[jid]
+                }
+            }
+            logger.debug({ deletedContacts: isLatest ? oldContacts.size : 0, newContacts }, 'synced contacts')
+            for (const msg of newMessages) {
+                const jid = msg.key.remoteJid
+                const list = assertMessageList(jid)
+                list.upsert(msg, 'prepend')
+            }
+            logger.debug({ messages: newMessages.length }, 'synced messages')
+        })
+        ev.on('contacts.upsert', contacts => {
+            contactsUpsert(contacts)
+        })
+        ev.on('contacts.update', async (updates) => {
+            for (const update of updates) {
+                let contact
+                if (contacts[update.id]) {
+                    contact = contacts[update.id]
+                }
+                else {
+                    const contactHashes = await Promise.all(Object.keys(contacts).map(async (contactId) => {
+                        const { user } = WABinary_1.jidDecode(contactId)
+                        return [contactId, (Utils_1.md5(Buffer.from(user + 'WA_ADD_NOTIF', 'utf8'))).toString('base64').slice(0, 3)]
+                    }))
+                    contact = contacts[contactHashes.find(([, b]) => b === update.id?.[0]) || ''] // find contact by attrs.hash, when user is not saved as a contact
+                }
+                if (!contact) {
+                    // Create new contact entry if the update has meaningful data
+                    if (update.notify || update.verifiedName || update.name) {
+                        contacts[update.id] = { id: update.id }
+                        contact = contacts[update.id]
+                    } else {
+                        logger.debug({ update }, 'got update for non-existant contact')
+                        continue
+                    }
+                }
+                if (update.imgUrl === 'changed') {
+                    contact.imgUrl = socket ? await socket.profilePictureUrl(contact.id) : undefined
+                }
+                else if (update.imgUrl === 'removed') {
+                    delete contact.imgUrl
+                }
+                // Persist pushName, verifiedName, and name from the update
+                if (update.notify) contact.notify = update.notify
+                if (update.verifiedName) contact.verifiedName = update.verifiedName
+                if (update.name) contact.name = update.name
+                Object.assign(contacts[contact.id], contact)
+            }
+        })
+        ev.on('chats.upsert', newChats => {
+            chats.upsert(...newChats)
+        })
+        ev.on('chats.update', updates => {
+            for (let update of updates) {
+                const result = chats.update(update.id, chat => {
+                    if (update.unreadCount > 0) {
+                        update = { ...update }
+                        update.unreadCount = (chat.unreadCount || 0) + update.unreadCount
+                    }
+                    Object.assign(chat, update)
+                })
+                if (!result) {
+                    logger.debug({ update }, 'got update for non-existant chat')
+                }
+            }
+        })
+        ev.on('labels.edit', (label) => {
+            if (label.deleted) {
+                return labels.deleteById(label.id)
+            }
+            // WhatsApp can store only up to 20 labels
+            if (labels.count() < 20) {
+                return labels.upsertById(label.id, label)
+            }
+            logger.error('Labels count exceed')
+        })
+        ev.on('labels.association', ({ type, association }) => {
+            switch (type) {
+                case 'add':
+                    labelAssociations.upsert(association)
+                    break
+                case 'remove':
+                    labelAssociations.delete(association)
+                    break
+                default:
+                    console.error(`unknown operation type [${type}]`)
+            }
+        })
+        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) {
+                if (chats.get(item)) {
+                    chats.deleteById(item)
+                }
+            }
+        })
+        ev.on('messages.upsert', ({ messages: newMessages, type }) => {
+            switch (type) {
+                case 'append':
+                case 'notify':
+                    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
+                                }
+                            ])
+                        }
+                    }
+                    break
+            }
+        })
+        ev.on('messages.update', updates => {
+            for (const { update, key } of updates) {
+                const list = assertMessageList(WABinary_1.jidNormalizedUser(key.remoteJid))
+                if (update?.status) {
+                    const listStatus = list.get(key.id)?.status
+                    if (listStatus && update?.status <= listStatus) {
+                        logger.debug({ update, storedStatus: listStatus }, 'status stored newer then update')
+                        delete update.status
+                        logger.debug({ update }, 'new update object')
+                    }
+                }
+                const result = list.updateAssign(key.id, update)
+                if (!result) {
+                    logger.debug({ update }, 'got update for non-existent message')
+                }
+            }
+        })
+        ev.on('messages.delete', item => {
+            if ('all' in item) {
+                const list = messages[item.jid]
+                list?.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))
+                }
+            }
+        })
+        ev.on('groups.update', updates => {
+            for (const update of updates) {
+                const id = update.id
+                if (groupMetadata[id]) {
+                    Object.assign(groupMetadata[id], update)
+                }
+                else {
+                    logger.debug({ update }, 'got update for non-existant group metadata')
+                }
+            }
+        })
+        ev.on('group-participants.update', ({ id, participants, action }) => {
+            const metadata = groupMetadata[id]
+            if (metadata) {
+                switch (action) {
+                    case 'add':
+                        metadata.participants.push(...participants.map(id => ({ id, isAdmin: false, isSuperAdmin: false })))
+                        break
+                    case 'demote':
+                    case 'promote':
+                        for (const participant of metadata.participants) {
+                            if (participants.includes(participant.id)) {
+                                participant.isAdmin = action === 'promote'
+                            }
+                        }
+                        break
+                    case 'remove':
+                        metadata.participants = metadata.participants.filter(p => !participants.includes(p.id))
+                        break
+                }
+            }
+        })
+        ev.on('message-receipt.update', updates => {
+            for (const { key, receipt } of updates) {
+                const obj = messages[key.remoteJid]
+                const msg = obj?.get(key.id)
+                if (msg) {
+                    Utils_1.updateMessageWithReceipt(msg, receipt)
+                }
+            }
+        })
+        ev.on('messages.reaction', (reactions) => {
+            for (const { key, reaction } of reactions) {
+                const obj = messages[key.remoteJid]
+                const msg = obj?.get(key.id)
+                if (msg) {
+                    Utils_1.updateMessageWithReaction(msg, reaction)
+                }
+            }
+        })
+    }
+    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.proto.WebMessageInfo.fromObject(msg), 'append')
+            }
+        }
+    }
+    return {
+        chats,
+        contacts,
+        messages,
+        groupMetadata,
+        state,
+        presences,
+        labels,
+        labelAssociations,
+        bind,
+        /** loads messages from the store, if not found -- uses the legacy connection */
+        loadMessages: async (jid, count, cursor) => {
+            const list = assertMessageList(jid)
+            const mode = !cursor || 'before' in cursor ? 'before' : 'after'
+            const cursorKey = !!cursor ? ('before' in cursor ? cursor.before : cursor.after) : undefined
+            const cursorValue = cursorKey ? list.get(cursorKey.id) : undefined
+            let messages
+            if (list && mode === 'before' && (!cursorKey || cursorValue)) {
+                if (cursorValue) {
+                    const msgIdx = list.array.findIndex(m => m.key.id === cursorKey?.id)
+                    messages = list.array.slice(0, msgIdx)
+                }
+                else {
+                    messages = list.array
+                }
+                const diff = count - messages.length
+                if (diff < 0) {
+                    messages = messages.slice(-count) // get the last X messages
+                }
+            }
+            else {
+                messages = []
+            }
+            return messages
+        },
+        /**
+         * Get all available labels for profile
+         *
+         * Keep in mind that the list is formed from predefined tags and tags
+         * that were "caught" during their editing.
+         */
+        getLabels: () => {
+            return labels
+        },
+        /**
+         * Get labels for chat
+         *
+         * @returns Label IDs
+         **/
+        getChatLabels: (chatId) => {
+            return labelAssociations.filter((la) => la.chatId === chatId).all()
+        },
+        /**
+         * Get labels for message
+         *
+         * @returns Label IDs
+         **/
+        getMessageLabels: (messageId) => {
+            const associations = labelAssociations
+                .filter((la) => la.messageId === messageId)
+                .all()
+            return associations.map(({ labelId }) => labelId)
+        },
+        loadMessage: async (jid, id) => messages[jid]?.get(id),
+        mostRecentMessage: async (jid) => {
+            const message = messages[jid]?.array.slice(-1)[0]
+            return message
+        },
+        fetchImageUrl: async (jid, sock) => {
+            const contact = contacts[jid]
+            if (!contact) {
+                return sock?.profilePictureUrl(jid)
+            }
+            if (typeof contact.imgUrl === 'undefined') {
+                contact.imgUrl = await sock?.profilePictureUrl(jid)
+            }
+            return contact.imgUrl
+        },
+        fetchGroupMetadata: async (jid, sock) => {
+            if (!groupMetadata[jid]) {
+                const metadata = await sock?.groupMetadata(jid)
+                if (metadata) {
+                    groupMetadata[jid] = metadata
+                }
+            }
+            return groupMetadata[jid]
+        },
+        // fetchBroadcastListInfo: async(jid: string, sock: WASocket | undefined) => {
+        // 	if(!groupMetadata[jid]) {
+        // 		const metadata = await sock?.getBroadcastListInfo(jid)
+        // 		if(metadata) {
+        // 			groupMetadata[jid] = metadata
+        // 		}
+        // 	}
+        // 	return groupMetadata[jid]
+        // },
+        fetchMessageReceipts: async ({ remoteJid, id }) => {
+            const list = messages[remoteJid]
+            const msg = list?.get(id)
+            return msg?.userReceipt
+        },
+        toJSON,
+        fromJSON,
+        writeToFile: (path) => {
+            // require fs here so that in case "fs" is not available -- the app does not crash
+            const { writeFileSync } = require('fs')
+            writeFileSync(path, JSON.stringify(toJSON()))
+        },
+        readFromFile: (path) => {
+            // require fs here so that in case "fs" is not available -- the app does not crash
+            const { readFileSync, existsSync } = require('fs')
+            if (existsSync(path)) {
+                logger.debug({ path }, 'reading from file')
+                const jsonStr = readFileSync(path, { encoding: 'utf-8' })
+                const json = JSON.parse(jsonStr)
+                fromJSON(json)
+            }
+        }
+    }
+}
+
+export { waChatKey, waMessageID, waLabelAssociationKey, makeInMemoryStore };