innovators-bot2 1.1.6 → 1.1.7

package/LID_STORE_GUIDE.md

@@ -0,0 +1,333 @@
+# Baileys v7.x.x LID Store Implementation Guide
+
+## Overview
+
+This guide explains how to properly implement and use the LID (Local Identifier) store functionality in Baileys v7.x.x, based on the official [migration guide](https://baileys.wiki/docs/migration/to-v7.0.0/).
+
+## What are LIDs?
+
+**LID (Local Identifier)** is WhatsApp's privacy feature that replaces phone numbers in large groups. Key points:
+
+- **Unique per user** (not per group)
+- Ensures user anonymity in large groups
+- Allows messaging users via either LID or PN (Phone Number)
+- Part of WhatsApp's transition to username system (@username)
+
+### JID Format Changes
+
+- **PN (Phone Number)**: `1234567890@s.whatsapp.net` (traditional format)
+- **LID**: `123456@lid` (new format)
+
+## Store Implementation
+
+### 1. Accessing the Store
+
+The store is initialized automatically when you create a socket and is accessible via:
+
+```javascript
+const store = sock.signalRepository.lidMapping;
+```
+
+### 2. Available Methods
+
+```javascript
+// Get LID from Phone Number
+const lid = await store.getLIDForPN('1234567890@s.whatsapp.net');
+
+// Get Phone Number from LID
+const pn = await store.getPNForLID('123456@lid');
+
+// Get multiple LIDs from multiple PNs
+const lids = await store.getLIDsForPNs([
+    '1234567890@s.whatsapp.net',
+    '0987654321@s.whatsapp.net'
+]);
+
+// Store a single mapping (usually automatic)
+await store.storeLIDPNMapping('1234567890@s.whatsapp.net', '123456@lid');
+
+// Store multiple mappings (usually automatic)
+await store.storeLIDPNMappings({
+    '1234567890@s.whatsapp.net': '123456@lid',
+    '0987654321@s.whatsapp.net': '654321@lid'
+});
+```
+
+## Implementation in Code
+
+### 1. Socket Initialization
+
+```javascript
+const { makeWASocket, useMultiFileAuthState } = require('@itsukichan/baileys');
+
+const { state, saveCreds } = await useMultiFileAuthState('auth_session');
+
+const sock = makeWASocket({
+    auth: state,
+    // ... other options
+});
+
+// Initialize store
+const store = sock.signalRepository.lidMapping;
+```
+
+### 2. Listen for LID Mapping Updates
+
+```javascript
+sock.ev.on('lid-mapping.update', async (update) => {
+    console.log('New LID/PN mappings received:', update);
+    // Mappings are automatically stored in the store
+    // You can emit custom events or perform additional processing
+});
+```
+
+### 3. Handle Messages with LID Support
+
+```javascript
+sock.ev.on('messages.upsert', async ({ messages }) => {
+    const message = messages[0];
+    
+    // Get the chat JID (prefer PN over LID)
+    let jid = message.key.remoteJid;
+    
+    // Use alternate JID if available (PN when primary is LID)
+    if (message.key.remoteJidAlt?.endsWith('@s.whatsapp.net')) {
+        jid = message.key.remoteJidAlt;
+    }
+    
+    // For group messages, get participant info
+    const participant = message.key.participant; // Could be LID or PN
+    const participantAlt = message.key.participantAlt; // Alternate format
+    
+    console.log('Message from:', jid);
+    console.log('Participant:', participant);
+    console.log('Participant Alt:', participantAlt);
+});
+```
+
+## Message Key Structure Changes
+
+### New Fields in MessageKey:
+
+```typescript
+interface MessageKey {
+    remoteJid: string;          // Primary JID (could be LID or PN)
+    remoteJidAlt?: string;      // Alternate JID for DMs
+    participant?: string;        // Sender in groups (could be LID or PN)
+    participantAlt?: string;    // Alternate JID for group senders
+    fromMe: boolean;
+    id: string;
+}
+```
+
+## Best Practices
+
+### 1. Prefer PN over LID for Compatibility
+
+```javascript
+// Always try to use PN (Phone Number) when available
+const getPreferredJid = (messageKey) => {
+    if (messageKey.remoteJidAlt?.endsWith('@s.whatsapp.net')) {
+        return messageKey.remoteJidAlt; // Use PN
+    }
+    return messageKey.remoteJid; // Fallback to primary JID
+};
+```
+
+### 2. Convert LID to PN When Needed
+
+```javascript
+const convertToPN = async (jid, store) => {
+    if (jid.endsWith('@lid')) {
+        const pn = await store.getPNForLID(jid);
+        return pn || jid; // Return PN if found, otherwise return LID
+    }
+    return jid;
+};
+```
+
+### 3. Handle Both Formats
+
+```javascript
+const sendMessageSafely = async (sock, store, recipientJid, content) => {
+    // Try to get PN if recipient is using LID
+    const jid = await convertToPN(recipientJid, store);
+    await sock.sendMessage(jid, content);
+};
+```
+
+## Authentication State Requirements
+
+⚠️ **Important**: Your authentication state must support these keys:
+- `lid-mapping`
+- `device-list`
+- `tctoken`
+
+Check `SignalDataTypeMap` in Baileys for the full type structure.
+
+## Events
+
+### 1. lid-mapping.update
+
+Emitted when new LID/PN mappings are discovered:
+
+```javascript
+sock.ev.on('lid-mapping.update', (update) => {
+    // update structure: { [pn: string]: lid: string }
+    Object.entries(update).forEach(([pn, lid]) => {
+        console.log(`Mapping: ${pn} -> ${lid}`);
+    });
+});
+```
+
+## Helper Functions
+
+### Check if JID is a PN
+
+```javascript
+const isPnUser = (jid) => {
+    return jid?.endsWith('@s.whatsapp.net');
+};
+```
+
+### Check if JID is a LID
+
+```javascript
+const isLidUser = (jid) => {
+    return jid?.endsWith('@lid');
+};
+```
+
+## Example Usage in WhatsAppClient
+
+```javascript
+class WhatsAppClient extends EventEmitter {
+    constructor() {
+        super();
+        this.sock = null;
+        this.store = null;
+    }
+
+    async connect() {
+        const { state, saveCreds } = await useMultiFileAuthState('session');
+        
+        this.sock = makeWASocket({ auth: state });
+        
+        // Initialize store
+        this.store = this.sock.signalRepository.lidMapping;
+        
+        // Listen for LID updates
+        this.sock.ev.on('lid-mapping.update', (update) => {
+            this.emit('lid-mapping-update', update);
+        });
+        
+        this.sock.ev.on('creds.update', saveCreds);
+    }
+    
+    async getLIDForPN(phoneNumber) {
+        return await this.store.getLIDForPN(phoneNumber);
+    }
+    
+    async getPNForLID(lid) {
+        return await this.store.getPNForLID(lid);
+    }
+}
+```
+
+## Common Use Cases
+
+### 1. Getting User's LID
+
+```javascript
+const userPN = '1234567890@s.whatsapp.net';
+const userLID = await client.getLIDForPN(userPN);
+console.log(`LID for ${userPN}: ${userLID}`);
+```
+
+### 2. Resolving LID to Phone Number
+
+```javascript
+const lid = '123456@lid';
+const phoneNumber = await client.getPNForLID(lid);
+console.log(`Phone number for ${lid}: ${phoneNumber}`);
+```
+
+### 3. Handling Group Messages
+
+```javascript
+sock.ev.on('messages.upsert', async ({ messages }) => {
+    const msg = messages[0];
+    
+    if (msg.key.remoteJid.endsWith('@g.us')) {
+        // Group message
+        const senderJid = msg.key.participant;
+        const senderPN = msg.key.participantAlt || senderJid;
+        
+        // Get LID if sender is using PN
+        if (senderPN.endsWith('@s.whatsapp.net')) {
+            const lid = await store.getLIDForPN(senderPN);
+            console.log(`Sender LID: ${lid}`);
+        }
+    }
+});
+```
+
+## Migration Notes
+
+### From Baileys v6.x to v7.x:
+
+1. **Remove `store` parameter** from `makeWASocket()` configuration
+2. **Access store via** `sock.signalRepository.lidMapping`
+3. **Update message handling** to check `remoteJidAlt` and `participantAlt`
+4. **Add event listener** for `lid-mapping.update`
+5. **Replace `isJidUser()`** with `isPnUser()`
+
+## Troubleshooting
+
+### Store is undefined
+
+**Problem**: `this.store` is `undefined`
+
+**Solution**: Ensure socket is properly initialized before accessing store:
+```javascript
+if (!this.sock || !this.sock.signalRepository) {
+    throw new Error('Socket not initialized');
+}
+this.store = this.sock.signalRepository.lidMapping;
+```
+
+### No LID found for PN
+
+**Problem**: `getLIDForPN()` returns `undefined`
+
+**Possible causes**:
+- User hasn't migrated to LID system yet
+- No LID/PN mapping received from WhatsApp server
+- Using old session that doesn't support LIDs
+
+**Solution**: Always handle `undefined` returns gracefully.
+
+### Auth state errors
+
+**Problem**: Connection fails with auth state errors
+
+**Solution**: Update your auth state implementation to support:
+- `lid-mapping`
+- `device-list`
+- `tctoken`
+
+## References
+
+- [Baileys Migration Guide](https://baileys.wiki/docs/migration/to-v7.0.0/)
+- [Baileys GitHub](https://github.com/WhiskeySockets/Baileys)
+- [WhatsApp LID System Announcement](https://whiskey.so/migrate-latest)
+
+## Summary
+
+The LID store in Baileys v7.x.x provides:
+- ✅ Automatic LID/PN mapping storage
+- ✅ Easy conversion between LIDs and phone numbers
+- ✅ Privacy-preserving messaging in large groups
+- ✅ Future-proof for WhatsApp's username system
+
+Always prefer using phone numbers (PNs) when available for better compatibility, but ensure your code handles both LIDs and PNs gracefully.

package/README.md

@@ -5,13 +5,15 @@ A powerful WhatsApp client library that provides seamless integration between Ba
 ## Features
 
 - 🚀 Easy to use, familiar WhatsApp-web.js style API
-- 📱 Multi-device support
+- 📱 Multi-device support (Baileys v7.x.x)
 - 💬 Send and receive messages
 - 📸 Media handling (images, videos, documents)
 - 👥 Group management
 - 💾 Message history and chat management
 - 🔄 Auto-reconnect functionality
 - 📝 Read receipts
+- 🔐 LID (Local Identifier) support for enhanced privacy
+- 🗂️ Signal repository store for LID/PN mapping
 
 ## Installation
 
@@ -233,6 +235,10 @@ The library includes example bot commands that you can use:
 - `!list` - Display a scrollable list
 - `!logout` - Logout from current session
 
+### LID/PN Management (v7.x.x)
+- `!lid` - Get your LID (Local Identifier)
+- `!pn <lid>` - Get phone number from a LID
+
 ## Event Handling
 
 ### Connection Events
@@ -276,6 +282,15 @@ client.on('message', async msg => {
 })
 ```
 
+### LID Mapping Events
+```javascript
+// Listen for LID/PN mapping updates
+client.on('lid-mapping-update', (update) => {
+    console.log('New LID/PN mappings received:', update)
+    // Handle new mappings as needed
+})
+```
+
 ### Error Handling
 
 ```javascript
@@ -301,6 +316,277 @@ try {
 }
 ```
 
+## Baileys v7.x.x LID Store Implementation
+
+### Overview
+
+This library fully supports Baileys v7.x.x LID (Local Identifier) system for enhanced privacy and WhatsApp's transition to username-based identification.
+
+| Feature | Description |
+|---------|-------------|
+| **LID Support** | Full support for Local Identifiers alongside Phone Numbers |
+| **Store Access** | Automatic initialization via `client.sock.signalRepository.lidMapping` |
+| **Helper Methods** | `getLIDForPN()`, `getPNForLID()`, `getLIDsForPNs()` |
+| **Event Handling** | `lid-mapping-update` event for real-time mapping updates |
+| **Message Handling** | Automatic preference for PN over LID with fallback support |
+| **Compatibility** | Backward compatible with v6.x code patterns |
+
+### What are LIDs?
+
+**LID (Local Identifier)** is WhatsApp's privacy feature that replaces phone numbers in large groups. Key points:
+
+- **Unique per user** (not per group)
+- Ensures user anonymity in large groups
+- Allows messaging users via either LID or PN (Phone Number)
+- Part of WhatsApp's transition to username system (@username)
+
+#### JID Format Changes
+
+- **PN (Phone Number)**: `1234567890@s.whatsapp.net` (traditional format)
+- **LID**: `123456@lid` (new format)
+
+### Accessing the Store
+
+The store is automatically initialized when you create a WhatsAppClient and is accessible via the internal socket:
+
+```javascript
+const client = new WhatsAppClient({ sessionName: ".Sessions" });
+await client.connect();
+
+// Store is available internally as client.store
+// Access via: client.sock.signalRepository.lidMapping
+```
+
+### Available Methods
+
+The WhatsAppClient provides convenient methods to work with LID/PN mappings:
+
+#### Quick Reference
+
+```javascript
+// Get LID from Phone Number
+const lid = await client.getLIDForPN('1234567890@s.whatsapp.net');
+
+// Get Phone Number from LID
+const pn = await client.getPNForLID('123456@lid');
+
+// Get multiple LIDs
+const lids = await client.getLIDsForPNs(['phone1@s.whatsapp.net', 'phone2@s.whatsapp.net']);
+```
+
+#### Detailed Examples
+
+```javascript
+// Get LID from Phone Number
+const lid = await client.getLIDForPN('1234567890@s.whatsapp.net');
+console.log('LID:', lid);
+
+// Get Phone Number from LID
+const pn = await client.getPNForLID('123456@lid');
+console.log('Phone Number:', pn);
+
+// Get multiple LIDs from multiple PNs
+const lids = await client.getLIDsForPNs([
+    '1234567890@s.whatsapp.net',
+    '0987654321@s.whatsapp.net'
+]);
+console.log('LIDs:', lids);
+```
+
+### Message Handling with LID Support
+
+The library automatically handles both LID and PN formats in messages:
+
+```javascript
+client.on('message', async msg => {
+    // msg.from will prefer PN over LID when available
+    console.log('Message from:', msg.from);
+    
+    // Access raw message key for both formats
+    const remoteJid = msg.raw.key.remoteJid;        // Primary JID
+    const remoteJidAlt = msg.raw.key.remoteJidAlt; // Alternate JID
+    
+    // For group messages
+    const participant = msg.raw.key.participant;       // Could be LID or PN
+    const participantAlt = msg.raw.key.participantAlt; // Alternate format
+    
+    // Convert LID to PN if needed
+    if (remoteJid.endsWith('@lid')) {
+        const phoneNumber = await client.getPNForLID(remoteJid);
+        console.log('Phone number:', phoneNumber);
+    }
+});
+```
+
+### Best Practices
+
+#### 1. Prefer PN over LID for Compatibility
+
+```javascript
+const getPreferredJid = (messageKey) => {
+    if (messageKey.remoteJidAlt?.endsWith('@s.whatsapp.net')) {
+        return messageKey.remoteJidAlt; // Use PN
+    }
+    return messageKey.remoteJid; // Fallback to primary JID
+};
+```
+
+#### 2. Convert LID to PN When Needed
+
+```javascript
+const convertToPN = async (jid) => {
+    if (jid.endsWith('@lid')) {
+        const pn = await client.getPNForLID(jid);
+        return pn || jid; // Return PN if found, otherwise return LID
+    }
+    return jid;
+};
+```
+
+#### 3. Handle Both Formats Gracefully
+
+```javascript
+// Always handle undefined returns
+const lid = await client.getLIDForPN(phoneNumber);
+if (lid) {
+    console.log('LID found:', lid);
+} else {
+    console.log('No LID mapping available, using PN');
+}
+```
+
+### Common Use Cases
+
+#### Getting User's LID
+
+```javascript
+client.on('message', async msg => {
+    if (msg.body === '!myid') {
+        const lid = await client.getLIDForPN(msg.from);
+        if (lid) {
+            await msg.reply(`Your LID: ${lid}\nYour PN: ${msg.from}`);
+        } else {
+            await msg.reply('No LID found. You may be using a PN-only session.');
+        }
+    }
+});
+```
+
+#### Resolving LID to Phone Number
+
+```javascript
+client.on('message', async msg => {
+    if (msg.body.startsWith('!lookup ')) {
+        const lid = msg.body.split(' ')[1];
+        const phoneNumber = await client.getPNForLID(lid);
+        
+        if (phoneNumber) {
+            await msg.reply(`Phone number: ${phoneNumber}`);
+        } else {
+            await msg.reply('No phone number found for that LID.');
+        }
+    }
+});
+```
+
+#### Handling Group Messages with LIDs
+
+```javascript
+client.on('message', async msg => {
+    if (msg.isGroup) {
+        const participant = msg.raw.key.participant;
+        const participantAlt = msg.raw.key.participantAlt;
+        
+        // Use alternate (PN) if available, otherwise use primary
+        const senderJid = participantAlt || participant;
+        
+        console.log('Group message from:', senderJid);
+        
+        // Get LID if sender is using PN
+        if (senderJid.endsWith('@s.whatsapp.net')) {
+            const lid = await client.getLIDForPN(senderJid);
+            console.log('Sender LID:', lid);
+        }
+    }
+});
+```
+
+### Helper Functions
+
+```javascript
+// Check if JID is a Phone Number
+const isPnUser = (jid) => {
+    return jid?.endsWith('@s.whatsapp.net');
+};
+
+// Check if JID is a LID
+const isLidUser = (jid) => {
+    return jid?.endsWith('@lid');
+};
+
+// Get preferred JID format
+const getPreferredFormat = async (jid, client) => {
+    if (isLidUser(jid)) {
+        const pn = await client.getPNForLID(jid);
+        return pn || jid;
+    }
+    return jid;
+};
+```
+
+### Authentication State Requirements
+
+⚠️ **Important**: Your authentication state must support these keys:
+- `lid-mapping` - Stores LID/PN mappings
+- `device-list` - Manages linked devices
+- `tctoken` - Token for communications
+
+The library handles this automatically with `useMultiFileAuthState`.
+
+### Migration from v6.x to v7.x
+
+If you're upgrading from Baileys v6.x:
+
+1. **Store access changed**: Access via `sock.signalRepository.lidMapping` instead of separate store parameter
+2. **New message key fields**: Check for `remoteJidAlt` and `participantAlt`
+3. **Event listener**: Add handler for `lid-mapping-update` event
+4. **Function naming**: `isJidUser()` replaced with `isPnUser()`
+5. **Automatic handling**: The WhatsAppClient already implements these changes
+
+### Troubleshooting
+
+#### Store is undefined
+
+**Problem**: Cannot access LID store methods
+
+**Solution**: Ensure client is connected before accessing store:
+```javascript
+await client.connect();
+// Wait for 'connected' event
+client.on('connected', async () => {
+    // Now store methods are available
+    const lid = await client.getLIDForPN(phoneNumber);
+});
+```
+
+#### No LID found for PN
+
+**Problem**: `getLIDForPN()` returns `undefined`
+
+**Possible causes**:
+- User hasn't migrated to LID system yet
+- No LID/PN mapping received from WhatsApp server
+- Using old session that doesn't support LIDs
+
+**Solution**: Always handle `undefined` returns gracefully
+
+### Additional Resources
+
+For more detailed information about the LID system implementation, see:
+- [LID_STORE_GUIDE.md](./LID_STORE_GUIDE.md) - Complete implementation guide
+- [Baileys Migration Guide](https://baileys.wiki/docs/migration/to-v7.0.0/) - Official migration documentation
+- [example.js](./example.js) - Working examples with LID handling
+
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.

package/example.js

@@ -32,6 +32,11 @@ client.on('connected', (user) => {
     console.log('Client is ready!', user)
 })
 
+// Handle LID mapping updates
+client.on('lid-mapping-update', (update) => {
+    console.log('New LID/PN mappings received:', update)
+})
+
 client.on('disconnected', (error) => {
     console.log('Client disconnected:')
 })
@@ -46,14 +51,16 @@ client.on('status', async status => {
     console.log ('Sender:', status.raw.pushName);
     console.log ('Message:', status.body);
     console.log ('Has Media:', status.hasMedia);
-    console.log('ID', status.key)
 
-    await client.readMessage(status.key)
-    await status.reply('Thanks for the status! ❤️');
-    await status.like('❤️');
-    console.log('Status Seen! and Replied With Emoji')
+    // Mark status as read using the complete message key
+
+    //await client.readMessage(status.key);
 
+    //Reply With Emoji
+    //await status.reply('Liked Your Status! ❤️');
 
+    await status.like('❤️');
+    console.log('Status Seen! and Replied With Emoji')
 });
 
 // Listen for incoming messages
@@ -323,6 +330,10 @@ client.on('message', async msg => {
             `• !buttons - Button template\n` +
             `• !list - Scrollable list\n\n` +
             
+            `*🔐 LID/PN Management*\n` +
+            `• !lid - Get your LID\n` +
+            `• !pn <lid> - Get PN from LID\n\n` +
+            
             `*⚙️ Admin Commands*\n` +
             `• !read - Mark as read\n` +
             `• !typing - Show typing\n` +
@@ -392,6 +403,40 @@ client.on('message', async msg => {
         case 'logout_no':
             await client.sendMessage(msg.from, 'Logout cancelled.');
             break;
+        case '!lid':
+            // Get LID for the user's phone number
+            try {
+                const lid = await client.getLIDForPN(msg.from);
+                if (lid) {
+                    await client.sendMessage(msg.from, `Your LID: ${lid}\nYour PN: ${msg.from}`);
+                } else {
+                    await client.sendMessage(msg.from, `No LID found for ${msg.from}. You might be using a PN-only session.`);
+                }
+            } catch (error) {
+                console.error('Error getting LID:', error);
+                await client.sendMessage(msg.from, 'Failed to get LID.');
+            }
+            break;
+        
+        case '!pn':
+            // Get PN from LID
+            try {
+                const lidToCheck = args.trim();
+                if (!lidToCheck) {
+                    await client.sendMessage(msg.from, 'Please provide a LID. Example: !pn 123456@lid');
+                    break;
+                }
+                const pn = await client.getPNForLID(lidToCheck);
+                if (pn) {
+                    await client.sendMessage(msg.from, `Phone Number for ${lidToCheck}: ${pn}`);
+                } else {
+                    await client.sendMessage(msg.from, `No phone number found for LID: ${lidToCheck}`);
+                }
+            } catch (error) {
+                console.error('Error getting PN from LID:', error);
+                await client.sendMessage(msg.from, 'Failed to get phone number.');
+            }
+            break;
         case '!ad':
                 await client.sendAdReply(
                     msg.from ,

package/index.js

@@ -4,6 +4,7 @@ const { makeWASocket,
         DisconnectReason, 
         fetchLatestBaileysVersion } = 
 require('@itsukichan/baileys');
+
 const { Boom } = require('@hapi/boom');
 const { EventEmitter } = require('events');
 const P = require('pino');
@@ -35,8 +36,7 @@ console.log(figlet.textSync('INNOVATORS'))
 console.log(figlet.textSync('SOFT'))
 console.log(figlet.textSync('PRO'))
 console.log(figlet.textSync('PAKISTANI'))
-
-
+   
 class Group {
     constructor(client, groupData) {
         this.client = client
@@ -49,7 +49,30 @@ class Group {
     }
 }
 
-
+/**
+ * WhatsApp Client class for Baileys v7.x.x
+ * 
+ * ## LID (Local Identifier) System
+ * Baileys v7.x.x introduces WhatsApp's LID system for user privacy in large groups.
+ * LIDs are unique identifiers that replace phone numbers in certain contexts.
+ * 
+ * ### Store Implementation:
+ * The store is accessible via `sock.signalRepository.lidMapping` and provides:
+ * - `getLIDForPN(phoneNumber)` - Get LID from phone number
+ * - `getPNForLID(lid)` - Get phone number from LID
+ * - `getLIDsForPNs(phoneNumbers)` - Get multiple LIDs
+ * - `storeLIDPNMapping(pn, lid)` - Store a single mapping
+ * - `storeLIDPNMappings(mappings)` - Store multiple mappings
+ * 
+ * ### Message Key Changes:
+ * - `remoteJidAlt` - Alternate JID for DMs (PN if primary is LID, or vice versa)
+ * - `participantAlt` - Alternate JID for group participants
+ * 
+ * ### Events:
+ * - `lid-mapping.update` - Emitted when new LID/PN mappings are received
+ * 
+ * @extends EventEmitter
+ */
 class WhatsAppClient extends EventEmitter {
     constructor(config = {}) {
         super()
@@ -82,9 +105,13 @@ class WhatsAppClient extends EventEmitter {
                 syncFullHistory: true,
                 generateHighQualityLinkPreview: true,
                 linkPreviewImageThumbnailWidth: 192,
-                emitOwnEvents: true
+                emitOwnEvents: true,
             });
 
+            // Initialize store for LID/PN mapping
+            this.store = this.sock.signalRepository.lidMapping;
+
+            
             this.sock.ev.on('connection.update', async (update) => {
                 const { connection, lastDisconnect, qr, isNewLogin, isOnline } = update;
 
@@ -159,11 +186,16 @@ class WhatsAppClient extends EventEmitter {
                     
                     let jid = message.key.remoteJid;
                     
+                    // Prefer PN (Phone Number) JID over LID for better compatibility
+                    // remoteJidAlt contains the alternate JID (PN if primary is LID, or vice versa)
                     if (typeof message.key.remoteJidAlt === 'string' &&
                         message.key.remoteJidAlt.endsWith('@s.whatsapp.net')
                     ) {
                         jid = message.key.remoteJidAlt;
                     }
+                    // For group messages, check participantAlt for sender's PN
+                    const participant = message.key.participant || null;
+                    const participantAlt = message.key.participantAlt || null;
                     
                     const timestamp = new Date((message.messageTimestamp || Date.now()) * 1000);
             
@@ -204,16 +236,23 @@ class WhatsAppClient extends EventEmitter {
                             timestamp,
                             key: message.key,
                             raw: message,
-            
                             // Reply to status
                             reply: async (text) => {
                                 if (!from) throw new Error('Missing participant JID');
                                 return this.sock.sendMessage(from, { text }, { quoted: message });
-                            },
-            
+                            },         
                             // 👍 Like (react) to status
                             like: async (emoji = '❤️') => {
                                 if (!from) throw new Error('Missing participant JID');
+                                
+                                // Read the message first
+                                try {
+                                    await this.sock.readMessages([message.key]);
+                                } catch (readError) {
+                                    console.error('Error reading status message:', readError);
+                                }
+                                
+                                // Then send the reaction
                                 return this.sock.sendMessage(from, {
                                     react: {
                                         text: emoji,
@@ -252,6 +291,30 @@ class WhatsAppClient extends EventEmitter {
                         // Handle incoming calls
             this.sock.ev.on('call', async (call) => {
                 try {
+                    // Extract phone number from LID if available
+                    for (const callData of call) {
+                        if (callData.chatId || callData.from) {
+                            const jid = callData.chatId || callData.from;
+                            
+                            // If it's a LID, try to get the phone number
+                            if (jid.endsWith('@lid')) {
+                                const phoneNumber = await this.store.getPNForLID(jid);
+                                
+                                if (phoneNumber) {
+                                    // Extract numeric part before colon (e.g., '923014434335' from '923014434335:0@s.whatsapp.net')
+                                    callData.phoneNumber = phoneNumber.split(':')[0].split('@')[0];
+                                } else {
+                                    // Fallback: extract from the numeric part before @lid
+                                    callData.phoneNumber = jid.split('@')[0];
+                                }
+                            } else {
+                                // For PN format, extract the number before colon and @
+                                callData.phoneNumber = jid.split(':')[0].split('@')[0];
+                            }
+                        }
+                    }
+                    
+                    console.log('Call received:', call);
                     await this.emit('call', call);
                 } catch (error) {
                     console.error('Error in call handler:', error);
@@ -259,6 +322,20 @@ class WhatsAppClient extends EventEmitter {
                 }
             });
 
+            // Handle LID/PN mapping updates
+            this.sock.ev.on('lid-mapping.update', async (update) => {
+                try {
+                    // Store the mapping for future use
+                    if (update && Object.keys(update).length > 0) {
+                        // The update object contains PN -> LID mappings
+                        // They are automatically stored in sock.signalRepository.lidMapping
+                        this.emit('lid-mapping-update', update);
+                    }
+                } catch (error) {
+                    console.error('Error processing LID mapping update:', error);
+                }
+            });
+
             // Handle credential updates
             this.sock.ev.on('creds.update', saveCreds);
 
@@ -646,17 +723,25 @@ class WhatsAppClient extends EventEmitter {
     }
     /**
      * Mark a message as read
-     * @param {string} messageId - The ID of the message to mark as read
+     * @param {object|string} messageKey - The message key object or message ID
      * @returns {Promise<void>}
      * @throws {Error} If client is not connected or an error occurs
      */
-    async readMessage(messageId) {
+    async readMessage(messageKey) {
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
 
         try {
-            await this.sock.readMessages([messageId]);
+            // If messageKey is a string (legacy), convert to key object format
+            // Otherwise use it directly as a key object
+            if (typeof messageKey === 'string') {
+                // Legacy support: just ID string
+                await this.sock.readMessages([{ id: messageKey }]);
+            } else {
+                // Proper key object with remoteJid, id, fromMe, etc.
+                await this.sock.readMessages([messageKey]);
+            }
         } catch (error) {
             console.error('Error marking message as read:', error);
             throw error;
@@ -811,6 +896,57 @@ class WhatsAppClient extends EventEmitter {
             throw error;
         }
     }
+    /**
+     * Get LID (Local Identifier) for a phone number
+     * @param {string} phoneNumber - Phone number in format: '1234567890@s.whatsapp.net'
+     * @returns {Promise<string|undefined>} The LID for the phone number, or undefined if not found
+     */
+    async getLIDForPN(phoneNumber) {
+        if (!this.sock || !this.store) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            return await this.store.getLIDForPN(phoneNumber);
+        } catch (error) {
+            console.error('Error getting LID for PN:', error);
+            return undefined;
+        }
+    }
+
+    /**
+     * Get Phone Number for a LID (Local Identifier)
+     * @param {string} lid - LID in format: '123456@lid'
+     * @returns {Promise<string|undefined>} The phone number for the LID, or undefined if not found
+     */
+    async getPNForLID(lid) {
+        if (!this.sock || !this.store) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            return await this.store.getPNForLID(lid);
+        } catch (error) {
+            console.error('Error getting PN for LID:', error);
+            return undefined;
+        }
+    }
+
+    /**
+     * Get multiple LIDs for multiple phone numbers
+     * @param {Array<string>} phoneNumbers - Array of phone numbers
+     * @returns {Promise<Array<string>>} Array of LIDs
+     */
+    async getLIDsForPNs(phoneNumbers) {
+        if (!this.sock || !this.store) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            return await this.store.getLIDsForPNs(phoneNumbers);
+        } catch (error) {
+            console.error('Error getting LIDs for PNs:', error);
+            return [];
+        }
+    }
+
     /**
      * Log out from WhatsApp
      * @returns {Promise<boolean>} True if logout was successful

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "innovators-bot2",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "",
   "main": "index.js",
   "scripts": {