// When disconnected
client.on('disconnected', (error) => {
console.log('Client disconnected:', error)
})
`

$3

`javascript
// When a message receives a reaction
client.on('message-reaction', async (reaction) => {
console.log('Reaction received!')
console.log('Chat:', reaction.from)
console.log('Sender:', reaction.sender)
console.log('Emoji:', reaction.emoji)
console.log('Is removed:', reaction.isRemoved)

// Check if reaction was added or removed
if (reaction.isRemoved) {
console.log('User removed their reaction')
} else {
console.log(User reacted with: ${reaction.emoji})
}

// Access the message key that was reacted to
console.log('Message ID:', reaction.messageKey.id)

// For group messages, get the participant who reacted
if (reaction.from.endsWith('@g.us')) {
console.log('Participant who reacted:', reaction.sender)
}
})
`

#### Reaction Event Data Structure

The message-reaction event provides the following data:

| Property | Type | Description |
|----------|------|-------------|
| from | string | Chat JID where the reaction occurred (prefers PN over LID) |
| sender | string | JID of the user who reacted (in groups, this is the participant) |
| participant | string\|null | Original participant JID (could be LID or PN) |
| participantAlt | string\|null | Alternate participant JID format |
| emoji | string\|null | The emoji used for the reaction (null if removed) |
| isRemoved | boolean | true if the reaction was removed, false if added |
| messageKey | object | The message key object that was reacted to |
| timestamp | Date | When the reaction event was processed |
| raw | object | Raw reaction data from Baileys |

#### Sending Reactions

You can also send reactions to messages programmatically:

`javascript
// React to a message
await client.sendMessage(chatId, {
type: 'reaction',
emoji: '❤️',
messageKey: messageToReactTo.key
})

// Remove a reaction (send empty emoji)
await client.sendMessage(chatId, {
type: 'reaction',
emoji: '',
messageKey: messageToReactTo.key
})
`

$3

`javascript
// Global error handler
client.on('error', error => {
console.error('Client Error:', error)
// Handle specific error types
if (error.message.includes('Connection Closed')) {
console.log('Attempting to reconnect...')
client.connect()
}
})

// Example with try-catch
try {
await client.sendMessage(to, message)
} catch (error) {
console.error('Error sending message:', error)
if (error.message.includes('Not connected')) {
console.log('Reconnecting...')
await client.connect()
}
}
`

Baileys v7.x.x LID Store Implementation

$3

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 |

$3

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)

$3

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
`

$3

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);
`

$3

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);
}
});
`

$3

#### 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');
}
`

$3

#### 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);
}
}
});
`

$3

`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;
};
`

$3

⚠️ 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.

$3

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

$3

#### 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

$3

For more detailed information about the LID system implementation, see:
- LID_STORE_GUIDE.md - Complete implementation guide
- Baileys Migration Guide - Official migration documentation
- example.js - Working examples with LID handling

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Credits

Developed by Innovators Soft. Based on the @itsukichan/baileys library.