stfca 1.1.27 → 1.2.27

package/README.md

@@ -7,6 +7,8 @@
 > **Unofficial Facebook Chat API for Node.js** - Interact with Facebook Messenger programmatically for ST-BOT 
 > 
 > **Enhanced & Maintained by ST | Sheikh Tamim**
+>
+> 🔐 **Now with End-to-End Encryption (E2EE) Support!**
 
 ## 🌟 What's New in ST-FCA
 
@@ -14,9 +16,10 @@
 - 🔄 Auto-reconnect with configurable intervals
 - 📊 Better connection status indicators
 - 🎨 Improved console output with colors
-- 🔐 Enhanced security and stability
+- 🔐 **NEW: End-to-End Encryption (E2EE) Support** - Full E2EE messaging system
 - 🚀 Automatic update checking and installation
 - 💡 Better error handling and debugging
+- 🔐 Enhanced security and stability
 
 ## 📦 Installation
 
@@ -179,7 +182,228 @@ login({ appState: [] }, (err, api) => {
 });
 ```
 
-## 📝 Message Types
+## � E2EE (End-to-End Encryption) - NEW FEATURE
+
+ST-FCA now includes **full End-to-End Encryption support** for secure encrypted messaging!
+
+### What is E2EE?
+
+E2EE (End-to-End Encryption) ensures that messages are encrypted on the sender's device and only decrypted on the recipient's device. No one in between (including servers) can read your messages.
+
+### E2EE Features
+
+✅ **Encrypted Messages** - All messages are encrypted  
+✅ **Encrypted Attachments** - Photos, videos, files encrypted  
+✅ **Automatic Detection** - Auto-routes between E2EE and standard messages  
+✅ **Message Reactions** - React to encrypted messages  
+✅ **Message Editing** - Edit encrypted messages  
+✅ **Typing Indicators** - Send typing indicators over E2EE  
+✅ **Device Persistence** - Reuse device keys across sessions  
+✅ **Media Server** - Local cache for decrypted files  
+
+### E2EE Quick Start
+
+```javascript
+const login = require("stfca");
+const fs = require("fs");
+
+login(
+    { appState: JSON.parse(fs.readFileSync("appstate.json", "utf8")) },
+    {
+        enableE2EE: true,  // 🔐 Enable E2EE
+        listenEvents: true,
+        autoMarkRead: true
+    },
+    (err, api) => {
+        if (err) return console.error(err);
+
+        // Connect E2EE Bridge
+        api.connectE2EE((err) => {
+            if (err) console.error("E2EE connection failed:", err);
+            console.log("✓ E2EE connected!");
+        });
+
+        // Get device data
+        api.getE2EEDeviceData((err, data) => {
+            if (!err) console.log("✓ Device data loaded");
+        });
+
+        // Listen for E2EE Messages
+        api.listenMqtt((err, event) => {
+            if (err) return console.error(err);
+
+            // Handle E2EE messages
+            if (event.type === "e2ee_message") {
+                console.log("🔐 E2EE Message:", event.body);
+                console.log("   Thread:", event.threadID);
+                console.log("   Encrypted: ✓ YES");
+
+                // Auto-reply with E2EE
+                api.sendMessage("Received: " + event.body, event.threadID);
+            }
+
+            // Handle E2EE reactions
+            if (event.type === "e2ee_message_reaction") {
+                console.log("🔐 E2EE Reaction:", event.reaction);
+            }
+
+            // Handle E2EE edits
+            if (event.type === "e2ee_message_edit") {
+                console.log("🔐 E2EE Message Edited:", event.body);
+            }
+        });
+    }
+);
+```
+
+### E2EE Event Types
+
+#### E2EE Message Event
+```javascript
+event.type === "e2ee_message"
+{
+    type: "e2ee_message",
+    senderID: "61568577897207",
+    threadID: "61568577897207:69@msgr",  // E2EE JID format
+    body: "Hello encrypted world!",
+    messageID: "m_1234567890",
+    isE2EE: true,  // 🔐 Marked as encrypted
+    isGroup: false,
+    timestamp: 1780805668000,
+    attachments: [],
+    mentions: {}
+}
+```
+
+#### E2EE Reaction Event
+```javascript
+event.type === "e2ee_message_reaction"
+{
+    type: "e2ee_message_reaction",
+    messageID: "m_1234567890",
+    reaction: "❤️",
+    userID: "61568577897207",
+    threadID: "61568577897207:69@msgr",
+    isE2EE: true
+}
+```
+
+#### E2EE Message Edit Event
+```javascript
+event.type === "e2ee_message_edit"
+{
+    type: "e2ee_message_edit",
+    messageID: "m_1234567890",
+    body: "Updated encrypted message",
+    senderID: "61568577897207",
+    isE2EE: true
+}
+```
+
+### E2EE API Methods
+
+```javascript
+// Enable E2EE in options
+api.setOptions({ enableE2EE: true });
+
+// Connect E2EE bridge
+api.connectE2EE(callback);
+
+// Get device encryption keys
+api.getE2EEDeviceData(callback);
+
+// Send encrypted message (auto-detected)
+api.sendMessage(message, e2eeThreadID, callback);
+
+// React to encrypted message
+api.setMessageReaction(emoji, messageID, callback);
+
+// Edit encrypted message
+api.editMessage(message, messageID, callback);
+
+// Unsend encrypted message
+api.unsendMessage(messageID, callback);
+
+// Send typing indicator (E2EE)
+api.sendTypingE2EE(threadID, callback);
+
+// Download encrypted media
+api.downloadE2EEMedia(messageID, callback);
+
+// Resolve encrypted attachment URL
+api.resolveE2EEAttachment(attachment);
+```
+
+### E2EE Connection Flow
+
+<img src="assest/e2eeconnect.png" alt="E2EE Connection Process" width="800"/>
+
+*Successful E2EE bridge connection showing:*
+- ✓ Login with cookies
+- ✓ MQTT connection established
+- ✓ E2EE bridge connected
+- ✓ Device keys established
+
+### E2EE Message Listening
+
+<img src="assest/e2eelisten.png" alt="E2EE Message Event" width="800"/>
+
+*E2EE message event showing:*
+- 🔐 Encrypted message received
+- ✓ Message JID format (E2EE identifier)
+- ✓ Sender and thread information
+- ✓ `isE2EE: true` flag
+
+### Configuration
+
+```javascript
+// In config.json
+{
+    "enableE2EE": true,
+    "enableTypingIndicator": true,
+    "typingDuration": 4000
+}
+```
+
+Or in login options:
+```javascript
+{
+    enableE2EE: true,
+    e2eeMemoryOnly: false,
+    autoReconnect: true,
+    listenEvents: true
+}
+```
+
+### Test E2EE Bot
+
+A complete E2EE test bot is included: [e2eebot.js](./e2eebot.js)
+
+```bash
+# Run the E2EE test bot
+node e2eebot.js
+```
+
+Commands:
+- `!ping` - Test bot response
+- `!info` - Show message info
+- `!echo <text>` - Echo message
+- `!react` - React with ❤️
+- `!help` - Show help
+
+### Full E2EE Documentation
+
+See [E2EE_GUIDE.md](./E2EE_GUIDE.md) for comprehensive documentation including:
+- ✅ System architecture
+- ✅ All API methods
+- ✅ Event types reference
+- ✅ Attachment handling
+- ✅ Device data management
+- ✅ Troubleshooting guide
+
+---
+
+## �📝 Message Types
 
 | Type                   | Usage                                                             |
 | ---------------------- | ----------------------------------------------------------------- |

package/index.js

@@ -279,6 +279,21 @@ function buildAPI(globalOptions, html, jar) {
         global.GoatBot.refreshFcaConfig = refreshFcaConfig;
     }
 
+    // ─── E2EE options from root config.json ────────────────────────────────────
+    try {
+        const _e2eeRootPath = path.join(process.cwd(), 'config.json');
+        if (fs.existsSync(_e2eeRootPath)) {
+            const _rootCfg = JSON.parse(fs.readFileSync(_e2eeRootPath, 'utf8'));
+            const _e2eeCfg = (_rootCfg && _rootCfg.e2ee) ? _rootCfg.e2ee : {};
+            if (_e2eeCfg.enable === true) globalOptions.enableE2EE = true;
+            // saveType: 'memory' (default) or 'path' (persist keys to devicePath)
+            var _saveType = _e2eeCfg.saveType || (typeof _e2eeCfg.memoryOnly !== 'undefined' ? (_e2eeCfg.memoryOnly ? 'memory' : 'path') : 'memory');
+            globalOptions.e2eeMemoryOnly = (_saveType !== 'path');
+            if (_saveType === 'path' && _e2eeCfg.devicePath) globalOptions.e2eeDevicePath = _e2eeCfg.devicePath;
+            if (_e2eeCfg.deviceData) globalOptions.e2eeDeviceData = _e2eeCfg.deviceData;
+        }
+    } catch (_) {}
+
     ctx.config = config;
     var api = {
         setOptions: setOptions.bind(null, globalOptions),
@@ -451,6 +466,51 @@ function buildAPI(globalOptions, html, jar) {
     };
     
     api.listen = api.listenMqtt;
+
+    // ─── E2EE: patch API + expose connectE2EE / getE2EEDeviceData ───────────────
+    if (globalOptions.enableE2EE) {
+        try {
+            var _e2ee = require('./e2ee');
+            _e2ee.patchApiForE2EE(api, ctx);
+
+            // api.connectE2EE(callback?) – start the E2EE client
+            api.connectE2EE = function (callback) {
+                var bridge = _e2ee.createBridge(ctx);
+                api._e2eeBridge = bridge;
+                return bridge.connect(callback);
+            };
+
+            // api.getE2EEBridge() – return the live bridge instance
+            api.getE2EEBridge = function () {
+                return ctx._e2eeBridge || null;
+            };
+
+            // api.getE2EEDeviceData(callback?) – fetch persistent device keys
+            api.getE2EEDeviceData = function (callback) {
+                var resolve, reject;
+                var promise = new Promise(function (res, rej) { resolve = res; reject = rej; });
+                if (ctx._e2eeDeviceData) {
+                    if (typeof callback === 'function') callback(null, ctx._e2eeDeviceData);
+                    resolve(ctx._e2eeDeviceData);
+                    return promise;
+                }
+                _e2ee.createBridge(ctx).getDeviceData()
+                    .then(function (d) {
+                        ctx._e2eeDeviceData = d;
+                        if (typeof callback === 'function') callback(null, d);
+                        resolve(d);
+                    })
+                    .catch(function (e) {
+                        if (typeof callback === 'function') callback(e);
+                        reject(e);
+                    });
+                return promise;
+            };
+        } catch (_patchErr) {
+            log.warn('E2EE', 'Failed to initialise E2EE:', _patchErr && _patchErr.message ? _patchErr.message : _patchErr);
+        }
+    }
+
     return {
         ctx,
         defaultFuncs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stfca",
-  "version": "1.1.27",
+  "version": "1.2.27",
   "description": "Unofficial Facebook Chat API for Node.js with Auto-Update System - Enhanced by ST | Sheikh Tamim",
   "main": "index.js",
   "files": [
@@ -46,7 +46,9 @@
     "update-function",
     "unofficial-facebook-chat-api",
     "messengerwapper",
-    "e2ee"
+    "e2ee",
+    "e2eefca",
+    "e2eesendmessage"
   ],
   "author": "ST | Sheikh Tamim",
   "license": "MIT",
@@ -62,14 +64,14 @@
     "duplexify": "^4.1.3",
     "gradient-string": "^2.0.2",
     "https-proxy-agent": "^7.0.6",
+    "koffi": "^3.0.2",
     "mime": "^3.0.0",
     "mqtt": "^5.10.1",
     "npmlog": "^1.2.0",
     "request": "^2.88.2",
     "totp-generator": "^1.0.0",
-    "ws": "^8.18.1"
-  },
-  "engines": {
-    "node": ">=16.0.0"
+    "undici": "^8.4.0",
+    "ws": "^8.18.1",
+    "yumi-json-bigint": "^1.0.0"
   }
 }

package/src/OldMessage.js

@@ -329,7 +329,7 @@ module.exports = function (defaultFuncs, api, ctx) {
                   handleUrl(msg, form, callback, () =>
                     handleEmoji(msg, form, callback, () =>
                       handleMention(msg, form, callback, () =>
-                        sendContent(form, threadID, isSingleUser, messageAndOTID, callback)
+                        sendContent(form, threadID, isGroup, messageAndOTID, callback)
                       )
                     )
                   )
@@ -344,7 +344,7 @@ module.exports = function (defaultFuncs, api, ctx) {
               handleUrl(msg, form, callback, () =>
                 handleEmoji(msg, form, callback, () =>
                   handleMention(msg, form, callback, () =>
-                    sendContent(form, threadID, isSingleUser, messageAndOTID, callback)
+                    sendContent(form, threadID, isGroup, messageAndOTID, callback)
                   )
                 )
               )

package/src/editMessage.js

@@ -23,6 +23,19 @@ function canBeCalled(func) {
 
 module.exports = function (defaultFuncs, api, ctx) {
     return function editMessage(text, messageID, callback) {
+        // ── editMessageE2EE: route E2EE messages through the bridge ──────────────
+        if (ctx.globalOptions && ctx.globalOptions.enableE2EE) {
+            var _e2eeMod = require('../e2ee');
+            var _jid = global._e2eeMessageMap && global._e2eeMessageMap.get(String(messageID));
+            if (_jid && _e2eeMod.isE2EEChatJid(_jid)) {
+                var _p = _e2eeMod.createBridge(ctx).editMessage(_jid, messageID, text)
+                    .then(function (r) { if (typeof callback === "function") callback(null, r); return r; })
+                    .catch(function (e) { if (typeof callback === "function") callback(e); throw e; });
+                return _p;
+            }
+        }
+        // ── end editMessageE2EE ───────────────────────────────────────────────────
+
         if (!ctx.mqttClient) {
             throw new Error('Not connected to MQTT');
         }
@@ -58,7 +71,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         context.payload = JSON.stringify(context.payload);
 
         // if (canBeCalled(callback)) {
-        // 	ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+        //      ctx.reqCallbacks[ctx.wsReqNumber] = callback;
         // }
 
         ctx.mqttClient.publish('/ls_req', JSON.stringify(context), {

package/src/listenMqtt.js

@@ -6,6 +6,7 @@ var mqtt = require('mqtt');
 var WebSocket = require('ws');
 var Transform = require('stream').Transform;
 const EventEmitter = require('events');
+var e2eeBridge = require("../e2ee");
 
 // ─── ANSI colour helpers ───────────────────────────────────────────────────────
 var C = {
@@ -399,6 +400,19 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
             clearTimeout(rTimeout);
             if (ctx.globalOptions.emitReady) globalCallback({ type: "ready", error: null });
             delete ctx.tmsWait;
+
+            // ── E2EE bridge init ──────────────────────────────────────────────────
+            ctx._globalCallback = globalCallback;
+            if (ctx.globalOptions.enableE2EE === true) {
+                var bridge = e2eeBridge.createBridge(ctx);
+                if (global.GoatBot) global.GoatBot._e2eeBridge = bridge;
+                bridge.connect(globalCallback).catch(function (err) {
+                    log.error("listenMqtt", "E2EE bridge connect error:", err && err.message ? err.message : err);
+                });
+            } else {
+                if (global.GoatBot) global.GoatBot._e2eeBridge = null;
+            }
+            // ── end E2EE bridge init ──────────────────────────────────────────────
         };
     });
 
@@ -885,4 +899,4 @@ module.exports = function (defaultFuncs, api, ctx) {
         api.stopListeningAsync = msgEmitter.stopListeningAsync.bind(msgEmitter);
         return msgEmitter;
     };
-};
+};

package/src/sendMessage.js

@@ -260,6 +260,98 @@ module.exports = function (defaultFuncs, api, ctx) {
             callback = function () { };
         }
 
+        // ── E2EE routing – sendMessageE2EE + sendMediaE2EE + downloadE2EEMedia ──
+        // When the destination thread is an E2EE JID (contains "@"), route through
+        // the Labyrinth native bridge instead of the MQTT/HTTP path.
+        // (Also exposes api.downloadE2EEMedia for decrypting received attachments.)
+        var _e2eeMod = require('../e2ee');
+        // Route to E2EE bridge whenever threadID is a JID — the "@" is definitive.
+        // Also respect explicit enableE2EE flag as a fallback check.
+        if (_e2eeMod.isE2EEChatJid(String(threadID))) {
+            var _bridge = _e2eeMod.createBridge(ctx);
+            var _form   = typeof msg === "string" ? { body: msg } : (msg || {});
+            var _text   = String(_form.body || _form.text || "");
+            var _atts   = !_form.attachment ? []
+                : (Array.isArray(_form.attachment) ? _form.attachment : [_form.attachment]);
+            var _sendOpts = {};
+            if (replyToMessage) {
+                _sendOpts.replyToId = String(replyToMessage);
+                var _rjid = global._e2eeSenderJidMap && global._e2eeSenderJidMap.get(String(replyToMessage));
+                if (_rjid) _sendOpts.replyToSenderJid = _rjid;
+            }
+
+            var _e2eePromise = (async function () {
+                var _last;
+                // sendMediaE2EE: send each attachment
+                for (var _i = 0; _i < _atts.length; _i++) {
+                    var _att = _atts[_i]; if (!_att) continue;
+                    try {
+                        var _buf;
+                        if (Buffer.isBuffer(_att)) {
+                            _buf = _att;
+                        } else if (_att && typeof _att.read === "function") {
+                            _buf = await new Promise(function (res, rej) {
+                                var chunks = [];
+                                _att.on("data", function (c) { chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)); });
+                                _att.on("end",  function ()  { res(Buffer.concat(chunks)); });
+                                _att.on("error", rej);
+                            });
+                        } else if (_att && _att.type === "Buffer" && Array.isArray(_att.data)) {
+                            _buf = Buffer.from(_att.data);
+                        } else { continue; }
+
+                        var _mt = (_att.mediaType ? String(_att.mediaType).toLowerCase() : null)
+                            || (function () {
+                                var p = String(_att.path || _att.filename || "").split(".").pop().toLowerCase();
+                                if (["jpg","jpeg","png","gif","webp","bmp"].includes(p)) return "image";
+                                if (["mp4","mov","avi","mkv","webm"].includes(p))        return "video";
+                                if (["mp3","ogg","oga","opus","wav","m4a","aac","flac"].includes(p)) return "audio";
+                                return "document";
+                            })();
+                        var _mOpts = Object.assign({}, _sendOpts);
+                        if (_i === 0 && _text) _mOpts.caption = _text;
+                        if (!_mOpts.mimeType && _att.mimeType) _mOpts.mimeType = _att.mimeType;
+                        if ((_mt === "file" || _mt === "document") && !_mOpts.filename)
+                            _mOpts.filename = (_att.filename || _att.path || "file.bin").split(/[\\/]/).pop();
+                        if (_att.duration != null) _mOpts.duration = Number(_att.duration);
+                        if (_att.width    != null) _mOpts.width    = Number(_att.width);
+                        if (_att.height   != null) _mOpts.height   = Number(_att.height);
+                        if (_att.ptt  || _att.voice) _mOpts.ptt = true;
+
+                        var _mRes = await _bridge.sendMedia(threadID, _mt, _buf, _mOpts);
+                        _last = { threadID: threadID, messageID: _mRes && _mRes.messageId ? String(_mRes.messageId) : undefined, isE2EE: true };
+                        if (_last.messageID) {
+                            global._e2eeMessageMap = global._e2eeMessageMap || new Map();
+                            global._e2eeMessageMap.set(_last.messageID, String(threadID));
+                            global._e2eeBotSentMsgIds = global._e2eeBotSentMsgIds || new Set();
+                            global._e2eeBotSentMsgIds.add(_last.messageID);
+                        }
+                    } catch (_me) { log.error("E2EE", "sendMedia att#" + _i + " failed:", _me && _me.message ? _me.message : _me); }
+                }
+                // sendMessageE2EE: send text (if no attachments, or text wasn't used as caption)
+                if (!_last || _atts.length === 0) {
+                    var _tRes = await _bridge.sendMessage(threadID, _text || "\u200b", _sendOpts);
+                    _last = { threadID: threadID, messageID: _tRes && _tRes.messageId ? String(_tRes.messageId) : undefined, isE2EE: true };
+                    if (_last.messageID) {
+                        global._e2eeMessageMap = global._e2eeMessageMap || new Map();
+                        global._e2eeMessageMap.set(_last.messageID, String(threadID));
+                        global._e2eeBotSentMsgIds = global._e2eeBotSentMsgIds || new Set();
+                        global._e2eeBotSentMsgIds.add(_last.messageID);
+                    }
+                }
+                return _last;
+            })();
+
+            // downloadE2EEMedia: exposed on api for received attachment decryption
+            if (typeof api.downloadE2EEMedia !== "function") {
+                api.downloadE2EEMedia = function (options) { return _bridge.downloadMedia(options); };
+            }
+
+            _e2eePromise.then(function (r) { callback(null, r); }).catch(function (e) { callback(e); });
+            return _e2eePromise;
+        }
+        // ── end E2EE routing ───────────────────────────────────────────────────────
+
         var msgType = utils.getType(msg);
         var threadIDType = utils.getType(threadID);
 
@@ -275,9 +367,15 @@ module.exports = function (defaultFuncs, api, ctx) {
         var configSource = (global.GoatBot && global.GoatBot.config) ? global.GoatBot.config : (ctx.config || {});
         var enableTypingIndicator = typeof configSource.enableTypingIndicator !== 'undefined' ? configSource.enableTypingIndicator : (ctx.config && ctx.config.enableTypingIndicator);
         var typingDuration = Number(configSource.typingDuration || (ctx.config && ctx.config.typingDuration) || 4000);
+        // E2EE threads need a longer visible duration — 1 second disappears before
+        // Messenger renders it. Use e2eeTypingDuration from config (default 3000 ms).
+        var _isE2EEThread = require('../e2ee').isE2EEChatJid(String(threadID));
+        if (_isE2EEThread) {
+            typingDuration = Number(configSource.e2eeTypingDuration || (ctx.config && ctx.config.e2eeTypingDuration) || 3000);
+        }
 
         if (enableTypingIndicator) {
-            await api.sendTypingIndicator(true, threadID, function () { });
+            await api.sendTypingIndicator(true, threadID, function () { }).catch(function () { });
             await utils.delay(typingDuration);
         }
 

package/src/sendTypingIndicator.js

@@ -1,45 +1,54 @@
-"use strict";
-
-
-
-var utils = require("../utils");
-// @NethWs3Dev
-
-module.exports = function (defaultFuncs, api, ctx) {
-	return async function sendTypingIndicatorV2(sendTyping, threadID, callback) {
-		const mqttClient = ctx.mqttClient || global.mqttClient;
-		if (!mqttClient) {
-			if (typeof callback === 'function') callback(new Error('No MQTT client available for typing indicator'));
-			return;
-		}
-
-		let count_req = 0;
-		var wsContent = {
-			app_id: 2220391788200892,
-			payload: JSON.stringify({
-				label: 3,
-				payload: JSON.stringify({
-					thread_key: threadID.toString(),
-					is_group_thread: +(threadID.toString().length >= 16),
-					is_typing: +sendTyping,
-					attribution: 0
-				}),
-				version: 5849951561777440
-			}),
-			request_id: ++count_req,
-			type: 4
-		};
-
-		return new Promise((resolve, reject) => {
-			mqttClient.publish('/ls_req', JSON.stringify(wsContent), {}, (err, _packet) => {
-				if (err) {
-					if (typeof callback === 'function') callback(err);
-					reject(err);
-				} else {
-					if (typeof callback === 'function') callback(null, _packet);
-					resolve(_packet);
-				}
-			});
-		});
-	};
-};
+"use strict";
+
+var utils = require("../utils");
+// @NethWs3Dev
+
+module.exports = function (defaultFuncs, api, ctx) {
+	return async function sendTypingIndicatorV2(sendTyping, threadID, callback) {
+		// ── sendTypingE2EE: route E2EE typing indicator through the bridge ──────
+		if (ctx.globalOptions && ctx.globalOptions.enableE2EE) {
+			var _e2eeMod = require('../e2ee');
+			if (_e2eeMod.isE2EEChatJid(String(threadID))) {
+				return _e2eeMod.createBridge(ctx).sendTyping(threadID, sendTyping !== false)
+					.then(function (r) { if (typeof callback === 'function') callback(null, r); return r; })
+					.catch(function (e) { if (typeof callback === 'function') callback(e); });
+			}
+		}
+		// ── end sendTypingE2EE ────────────────────────────────────────────────────
+
+		const mqttClient = ctx.mqttClient || global.mqttClient;
+		if (!mqttClient) {
+			if (typeof callback === 'function') callback(new Error('No MQTT client available for typing indicator'));
+			return;
+		}
+
+		let count_req = 0;
+		var wsContent = {
+			app_id: 2220391788200892,
+			payload: JSON.stringify({
+				label: 3,
+				payload: JSON.stringify({
+					thread_key: threadID.toString(),
+					is_group_thread: +(threadID.toString().length >= 16),
+					is_typing: +sendTyping,
+					attribution: 0
+				}),
+				version: 5849951561777440
+			}),
+			request_id: ++count_req,
+			type: 4
+		};
+
+		return new Promise((resolve, reject) => {
+			mqttClient.publish('/ls_req', JSON.stringify(wsContent), {}, (err, _packet) => {
+				if (err) {
+					if (typeof callback === 'function') callback(err);
+					reject(err);
+				} else {
+					if (typeof callback === 'function') callback(null, _packet);
+					resolve(_packet);
+				}
+			});
+		});
+	};
+};

package/src/setMessageReaction.js

@@ -26,6 +26,31 @@ module.exports = function (defaultFuncs, api, ctx) {
       };
     }
 
+    // ── sendReactionE2EE: route E2EE reactions through the bridge ─────────────
+    if (ctx.globalOptions && ctx.globalOptions.enableE2EE) {
+      var _e2eeMod = require('../e2ee');
+      var _jid = global._e2eeMessageMap && global._e2eeMessageMap.get(String(messageID));
+      if (_jid && _e2eeMod.isE2EEChatJid(_jid)) {
+        var _senderJid = (global._e2eeSenderJidMap && global._e2eeSenderJidMap.get(String(messageID))) || null;
+        // Always route through the bridge when the JID is confirmed E2EE —
+        // never fall through to the HTTP path which cannot reach E2EE threads.
+        // senderJid is required by the E2EE protocol; fall back to chatJid for DMs
+        // (in a DM the chatJid IS the other person's JID).
+        var _effectiveSender = _senderJid || _jid;
+        _e2eeMod.createBridge(ctx).sendReaction(_jid, messageID, _effectiveSender, reaction)
+          .then(function (r) { callback(null, r); resolveFunc(r); })
+          .catch(function (e) {
+            var log = require('../utils').log;
+            log.error("setMessageReaction", "E2EE sendReaction failed — jid:" + _jid +
+              " msgID:" + messageID + " sender:" + _effectiveSender + " emoji:" + reaction +
+              " err:" + (e && e.message ? e.message : String(e)));
+            callback(e); rejectFunc(e);
+          });
+        return returnPromise;
+      }
+    }
+    // ── end sendReactionE2EE ──────────────────────────────────────────────────
+
     switch (reaction) {
       case "\uD83D\uDE0D": //:heart_eyes:
       case "\uD83D\uDE06": //:laughing:

package/src/unsendMessage.js

@@ -21,6 +21,27 @@ module.exports = function (defaultFuncs, api, ctx) {
       };
     }
 
+    // ── unsendMessageE2EE: route E2EE unsend through the bridge ─────────────
+    if (ctx.globalOptions && ctx.globalOptions.enableE2EE) {
+      var _e2eeMod = require('../e2ee');
+      var _jid = global._e2eeMessageMap && global._e2eeMessageMap.get(String(messageID));
+      // Fallback: if messageID not in map but a pending JID was set externally, use it
+      if (!_jid && global._e2eePendingUnsendJid) {
+        var _pjid = global._e2eePendingUnsendJid[String(messageID)];
+        if (_pjid) {
+          _jid = _pjid;
+          delete global._e2eePendingUnsendJid[String(messageID)];
+        }
+      }
+      if (_jid && _e2eeMod.isE2EEChatJid(_jid)) {
+        _e2eeMod.createBridge(ctx).unsendMessage(_jid, messageID)
+          .then(function (r) { callback(null, r); resolveFunc(r); })
+          .catch(function (e) { callback(e); rejectFunc(e); });
+        return returnPromise;
+      }
+    }
+    // ── end unsendMessageE2EE ─────────────────────────────────────────────────
+
     const form = {
       message_id: messageID,
     };