fca-phantom 1.0.0

package/phantom/dispatch/deleteMessage.js

@@ -0,0 +1,131 @@
+"use strict";
+
+/**
+ * deleteMessage — Advanced Message Deletion for Phantom SDK
+ *
+ * Features:
+ *  - Primary: GraphQL mutation (newer approach, supports recall)
+ *  - Fallback: Legacy mercury delete endpoint
+ *  - Batch delete: pass an array of messageIDs
+ *  - Configurable concurrency for batch operations
+ *  - Exponential-backoff retry on transient errors
+ *  - Detailed success/failure per-message result objects
+ *  - Full callback + Promise dual API
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+async function deleteGraphQL(defaultFuncs, ctx, messageID) {
+  const form = {
+    av:                       ctx.userID,
+    __user:                   ctx.userID,
+    __a:                      1,
+    fb_dtsg:                  ctx.fb_dtsg,
+    lsd:                      ctx.lsd || ctx.fb_dtsg,
+    fb_api_caller_class:      "RelayModern",
+    fb_api_req_friendly_name: "useDeleteMessageMutation",
+    variables: JSON.stringify({
+      input: {
+        client_mutation_id: String(Date.now() % 1e9),
+        actor_id:           ctx.userID,
+        message_id:         messageID,
+        delete_type:        "DELETE_FOR_ME",
+      }
+    }),
+    server_timestamps: true,
+    doc_id:            "6090627834316949",
+  };
+
+  const res     = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form);
+  const checked = await utils.parseAndCheckLogin(ctx, defaultFuncs)(res);
+  if (checked?.errors) throw Object.assign(new Error(checked.errors[0]?.message || JSON.stringify(checked.errors)), { isFatal: true });
+  return { success: true, messageID, method: 'graphql' };
+}
+
+async function deleteLegacy(defaultFuncs, ctx, messageID) {
+  const res = await defaultFuncs.post(
+    "https://www.facebook.com/ajax/mercury/delete_messages.php",
+    ctx.jar,
+    { message_id: messageID }
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res?.error) throw new Error(JSON.stringify(res.error));
+  return { success: true, messageID, method: 'legacy' };
+}
+
+async function deleteOne(defaultFuncs, ctx, messageID, retries, baseMs) {
+  let lastErr;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await deleteGraphQL(defaultFuncs, ctx, messageID);
+    } catch (gqlErr) {
+      try {
+        return await deleteLegacy(defaultFuncs, ctx, messageID);
+      } catch (legacyErr) {
+        lastErr = gqlErr;
+        if (attempt >= retries || gqlErr.isFatal) throw gqlErr;
+        const wait = baseMs * Math.pow(2, attempt - 1) + Math.random() * 200;
+        utils.warn("deleteMessage", `Retry ${attempt}/${retries} for ${messageID} in ${Math.round(wait)}ms`);
+        await new Promise(r => setTimeout(r, wait));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+
+  /**
+   * Delete one or more messages.
+   *
+   * @param {string|string[]} messageID    Single ID or array for batch delete
+   * @param {object}          [options]
+   *   @param {number} [options.retries=3]       Max retry attempts per message
+   *   @param {number} [options.concurrency=3]   Max parallel deletions in batch mode
+   * @param {Function}        [callback]   Node-style (err, result) callback
+   * @returns {Promise<object|object[]>}
+   */
+  return async function deleteMessage(messageID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    options = options || {};
+
+    const retries     = options.retries     || 3;
+    const concurrency = options.concurrency || 3;
+    const baseMs      = 500;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => { resolveFunc = resolve; rejectFunc = reject; });
+
+    function done(err, result) {
+      if (callback) return err ? callback(err) : callback(null, result);
+      if (err) rejectFunc(err); else resolveFunc(result);
+    }
+
+    const ids = Array.isArray(messageID) ? messageID : [messageID];
+
+    if (!ids.length || ids.some(id => !id)) {
+      done(new Error("deleteMessage: messageID is required"));
+      return returnPromise;
+    }
+
+    try {
+      const results = [];
+      // Process in concurrency-limited batches
+      for (let i = 0; i < ids.length; i += concurrency) {
+        const batch  = ids.slice(i, i + concurrency);
+        const batchR = await Promise.allSettled(batch.map(id => deleteOne(defaultFuncs, ctx, id, retries, baseMs)));
+        for (const r of batchR) {
+          results.push(r.status === 'fulfilled' ? r.value : { success: false, messageID: batch[results.length % batch.length], error: r.reason?.message });
+        }
+      }
+
+      const out = ids.length === 1 ? results[0] : { success: results.every(r => r.success), results };
+      done(null, out);
+    } catch (err) {
+      utils.error("deleteMessage", err.message || err);
+      done(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/deleteThread.js

@@ -0,0 +1,155 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const CHUNK_SIZE = 10;
+const DELETE_DELAY_MS = 500;
+
+async function retryOp(fn, retries = 3, base = 500) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 200));
+    }
+  }
+}
+
+async function deleteChunk(defaultFuncs, ctx, chunk) {
+  const form = { client: "mercury" };
+  chunk.forEach((id, i) => { form[`ids[${i}]`] = id; });
+  const res = await defaultFuncs.post(
+    "https://www.facebook.com/ajax/mercury/delete_thread.php",
+    ctx.jar,
+    form
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  if (res && res.error) throw res;
+  return chunk;
+}
+
+async function mqttDeleteThread(ctx, threadIDs) {
+  return new Promise((resolve, reject) => {
+    if (!ctx.mqttClient) return reject(new Error("MQTT not connected"));
+
+    const reqID = ++ctx.wsReqNumber;
+    const tasks = threadIDs.map((id) => ({
+      failure_count: null,
+      label: "19",
+      payload: JSON.stringify({ thread_key: id, sync_group: 1 }),
+      queue_name: "delete_thread",
+      task_id: ++ctx.wsTaskNumber
+    }));
+
+    const form = JSON.stringify({
+      app_id: "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks,
+        version_id: "8798795233522156"
+      }),
+      request_id: reqID,
+      type: 3
+    });
+
+    let handled = false;
+    const onResp = (topic, message) => {
+      if (topic !== "/ls_resp" || handled) return;
+      let j;
+      try { j = JSON.parse(message.toString()); j.payload = JSON.parse(j.payload); } catch { return; }
+      if (j.request_id !== reqID) return;
+      handled = true;
+      clearTimeout(timer);
+      ctx.mqttClient.removeListener("message", onResp);
+      resolve({ success: true, deletedThreads: threadIDs, method: "mqtt" });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener("message", onResp);
+        resolve({ success: true, deletedThreads: threadIDs, method: "mqtt_no_ack" });
+      }
+    }, 15000);
+
+    ctx.mqttClient.on("message", onResp);
+    ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener("message", onResp);
+        reject(err);
+      }
+    });
+  });
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function deleteThread(threadOrThreads, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof callback !== "function") {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const threads = Array.isArray(threadOrThreads)
+        ? threadOrThreads.map(String)
+        : [String(threadOrThreads)];
+
+      if (threads.length === 0) throw new Error("deleteThread: no threadIDs provided");
+
+      await globalShield.addSmartDelay();
+
+      const deleted = [];
+      const failed = [];
+
+      if (ctx.mqttClient) {
+        for (let i = 0; i < threads.length; i += CHUNK_SIZE) {
+          const chunk = threads.slice(i, i + CHUNK_SIZE);
+          try {
+            const res = await retryOp(() => mqttDeleteThread(ctx, chunk));
+            deleted.push(...res.deletedThreads);
+          } catch (err) {
+            utils.warn("deleteThread", "MQTT chunk failed, using HTTP:", err.message);
+            try {
+              const res = await retryOp(() => deleteChunk(defaultFuncs, ctx, chunk));
+              deleted.push(...res);
+            } catch (httpErr) {
+              failed.push(...chunk);
+            }
+          }
+          if (i + CHUNK_SIZE < threads.length) {
+            await new Promise(r => setTimeout(r, DELETE_DELAY_MS));
+          }
+        }
+      } else {
+        for (let i = 0; i < threads.length; i += CHUNK_SIZE) {
+          const chunk = threads.slice(i, i + CHUNK_SIZE);
+          try {
+            const res = await retryOp(() => deleteChunk(defaultFuncs, ctx, chunk));
+            deleted.push(...res);
+          } catch (err) {
+            failed.push(...chunk);
+          }
+          if (i + CHUNK_SIZE < threads.length) {
+            await new Promise(r => setTimeout(r, DELETE_DELAY_MS));
+          }
+        }
+      }
+
+      callback(null, { success: true, deleted, failed, count: deleted.length });
+    } catch (err) {
+      utils.error("deleteThread", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/phantom/dispatch/e2ee.js

@@ -0,0 +1,101 @@
+"use strict";
+
+const e2ee = require('../datastore/models/cipher/e2ee');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const PEER_CACHE = new Map();
+
+  function getPeerCount() {
+    if (!ctx._e2eePeers) return 0;
+    return Object.keys(ctx._e2eePeers).length;
+  }
+
+  function getStats() {
+    return {
+      enabled: e2ee.isEnabled(ctx),
+      peerCount: getPeerCount(),
+      hasPublicKey: !!e2ee.getPublicKey(ctx),
+      peerIDs: ctx._e2eePeers ? Object.keys(ctx._e2eePeers) : []
+    };
+  }
+
+  function exportKeyring() {
+    return {
+      publicKey: e2ee.getPublicKey(ctx),
+      peers: ctx._e2eePeers ? { ...ctx._e2eePeers } : {},
+      exportedAt: Date.now()
+    };
+  }
+
+  function importKeyring(keyring) {
+    if (!keyring || typeof keyring !== "object") throw new Error("e2ee.importKeyring: invalid keyring object");
+    if (keyring.peers && typeof keyring.peers === "object") {
+      for (const [threadID, key] of Object.entries(keyring.peers)) {
+        e2ee.setPeerKey(ctx, threadID, key);
+      }
+    }
+    return { success: true, importedPeers: Object.keys(keyring.peers || {}).length };
+  }
+
+  function encryptBatch(entries) {
+    if (!Array.isArray(entries)) throw new Error("e2ee.encryptBatch: entries must be an array");
+    return entries.map(({ threadID, text }) => {
+      try {
+        return { threadID, encrypted: e2ee.encrypt(ctx, threadID, text), error: null };
+      } catch (err) {
+        return { threadID, encrypted: null, error: err.message };
+      }
+    });
+  }
+
+  function decryptBatch(entries) {
+    if (!Array.isArray(entries)) throw new Error("e2ee.decryptBatch: entries must be an array");
+    return entries.map(({ threadID, armored }) => {
+      try {
+        return { threadID, decrypted: e2ee.decrypt(ctx, threadID, armored), error: null };
+      } catch (err) {
+        return { threadID, decrypted: null, error: err.message };
+      }
+    });
+  }
+
+  function rotatePeerKey(threadID, newPeerPublicKeyB64) {
+    e2ee.clearPeerKey(ctx, threadID);
+    e2ee.setPeerKey(ctx, newPeerPublicKeyB64 ? threadID : null, newPeerPublicKeyB64);
+    return { success: true, threadID, rotated: !!newPeerPublicKeyB64 };
+  }
+
+  return {
+    enable() { e2ee.enable(ctx); return { success: true, enabled: true }; },
+    disable() { e2ee.disable(ctx); return { success: true, enabled: false }; },
+    isEnabled() { return e2ee.isEnabled(ctx); },
+    getPublicKey() { return e2ee.getPublicKey(ctx); },
+    setPeerKey(threadID, peerPublicKeyB64) {
+      if (!threadID) throw new Error("e2ee.setPeerKey: threadID is required");
+      if (!peerPublicKeyB64) throw new Error("e2ee.setPeerKey: peerPublicKeyB64 is required");
+      e2ee.setPeerKey(ctx, threadID, peerPublicKeyB64);
+      PEER_CACHE.set(threadID, { key: peerPublicKeyB64, ts: Date.now() });
+      return { success: true, threadID };
+    },
+    clearPeerKey(threadID) {
+      e2ee.clearPeerKey(ctx, threadID);
+      PEER_CACHE.delete(threadID);
+      return { success: true, threadID };
+    },
+    hasPeer(threadID) { return e2ee.hasPeer(ctx, threadID); },
+    encrypt(threadID, text) { return e2ee.encrypt(ctx, threadID, text); },
+    decrypt(threadID, armored) { return e2ee.decrypt(ctx, threadID, armored); },
+    getStats,
+    exportKeyring,
+    importKeyring,
+    encryptBatch,
+    decryptBatch,
+    rotatePeerKey,
+    clearAllPeers() {
+      const peers = ctx._e2eePeers ? Object.keys(ctx._e2eePeers) : [];
+      peers.forEach(id => e2ee.clearPeerKey(ctx, id));
+      PEER_CACHE.clear();
+      return { success: true, clearedCount: peers.length };
+    }
+  };
+};

package/phantom/dispatch/editMessage.js

@@ -0,0 +1,158 @@
+"use strict";
+
+/**
+ * editMessage — Advanced Message Editor for Phantom SDK
+ *
+ * @author RFS-ADRENO (original) — massively extended for phantom-fca
+ *
+ * Features:
+ *  - MQTT path (primary) — low-latency realtime edit via /ls_req
+ *  - GraphQL mutation fallback — when MQTT unavailable or fails
+ *  - Input validation (text length, messageID format)
+ *  - Retry with exponential backoff on MQTT publish errors
+ *  - Promise callback support (returns Promise when no callback given)
+ *  - Preserves originalText + editedAt metadata in resolve value
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+const MAX_TEXT_LENGTH = 20000;
+
+async function editViaMqtt(ctx, text, messageID, retries, baseMs) {
+  if (!ctx.mqttClient) throw new Error("editMessage: MQTT client is not connected");
+
+  let lastErr;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    ctx.wsReqNumber  = (ctx.wsReqNumber  || 0) + 1;
+    ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+    const payload = {
+      failure_count: null,
+      label:         '742',
+      payload:       JSON.stringify({ message_id: messageID, text }),
+      queue_name:    'edit_message',
+      task_id:       ctx.wsTaskNumber,
+    };
+
+    const content = {
+      app_id:     '2220391788200892',
+      payload:    JSON.stringify({
+        data_trace_id: null,
+        epoch_id:      parseInt(utils.generateOfflineThreadingID ? utils.generateOfflineThreadingID() : Date.now()),
+        tasks:         [payload],
+        version_id:    '6903494529735864',
+      }),
+      request_id: ctx.wsReqNumber,
+      type:       3,
+    };
+
+    try {
+      await new Promise((resolve, reject) => {
+        ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false }, err => {
+          if (err) reject(new Error(`MQTT publish failed: ${err.message}`));
+          else resolve();
+        });
+      });
+      return { success: true, messageID, text, method: 'mqtt', editedAt: Date.now() };
+    } catch (err) {
+      lastErr = err;
+      if (attempt >= retries) throw err;
+      const wait = baseMs * Math.pow(2, attempt - 1) + Math.random() * 150;
+      utils.warn("editMessage", `MQTT retry ${attempt}/${retries} in ${Math.round(wait)}ms`);
+      await new Promise(r => setTimeout(r, wait));
+    }
+  }
+  throw lastErr;
+}
+
+async function editViaGraphQL(defaultFuncs, ctx, text, messageID) {
+  const form = {
+    av:                       ctx.userID,
+    __user:                   ctx.userID,
+    __a:                      1,
+    fb_dtsg:                  ctx.fb_dtsg,
+    lsd:                      ctx.lsd || ctx.fb_dtsg,
+    fb_api_caller_class:      "RelayModern",
+    fb_api_req_friendly_name: "useEditMessageMutation",
+    variables: JSON.stringify({
+      input: {
+        client_mutation_id: String(Date.now() % 1e9),
+        actor_id:           ctx.userID,
+        message_id:         messageID,
+        text,
+      }
+    }),
+    server_timestamps: true,
+    doc_id:            "6363606433743285",
+  };
+
+  const res     = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form);
+  const checked = await utils.parseAndCheckLogin(ctx, defaultFuncs)(res);
+  if (checked?.errors) throw new Error(checked.errors[0]?.message || JSON.stringify(checked.errors));
+  return { success: true, messageID, text, method: 'graphql', editedAt: Date.now() };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  /**
+   * Edit a previously sent message.
+   *
+   * @param {string}   text       New message text
+   * @param {string}   messageID  ID of the message to edit
+   * @param {object}  [options]   { retries, preferGraphQL }
+   * @param {Function} [callback] Node-style (err, result) callback
+   * @returns {Promise<object>}   { success, messageID, text, method, editedAt }
+   */
+  return async function editMessage(text, messageID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    options = options || {};
+
+    const retries = options.retries || 3;
+    const baseMs  = 500;
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((res, rej) => { resolveFunc = res; rejectFunc = rej; });
+
+    function done(err, data) {
+      if (callback) return err ? callback(err) : callback(null, data);
+      if (err) rejectFunc(err); else resolveFunc(data);
+    }
+
+    // Validation
+    if (typeof text !== 'string' || !text.trim()) {
+      done(new Error("editMessage: text must be a non-empty string"));
+      return promise;
+    }
+    if (!messageID) {
+      done(new Error("editMessage: messageID is required"));
+      return promise;
+    }
+    if (text.length > MAX_TEXT_LENGTH) {
+      done(new Error(`editMessage: text exceeds maximum length of ${MAX_TEXT_LENGTH} characters`));
+      return promise;
+    }
+
+    const sanitized = text.trimEnd();
+
+    try {
+      let result;
+      if (!options.preferGraphQL && ctx.mqttClient) {
+        try {
+          result = await editViaMqtt(ctx, sanitized, messageID, retries, baseMs);
+        } catch (mqttErr) {
+          utils.warn("editMessage", `MQTT failed — falling back to GraphQL: ${mqttErr.message}`);
+          result = await editViaGraphQL(defaultFuncs, ctx, sanitized, messageID);
+        }
+      } else {
+        result = await editViaGraphQL(defaultFuncs, ctx, sanitized, messageID);
+      }
+
+      done(null, result);
+    } catch (err) {
+      utils.error("editMessage", err.message || err);
+      done(err);
+    }
+
+    return promise;
+  };
+};

package/phantom/dispatch/emoji.js

@@ -0,0 +1,143 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+async function retryOp(fn, retries = 3, base = 500) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 200));
+    }
+  }
+}
+
+async function mqttSetEmoji(ctx, emoji, threadID, initiatorID) {
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const context = JSON.stringify({
+      app_id: ctx.appID || "2220391788200892",
+      payload: JSON.stringify({
+        epoch_id: parseInt(utils.generateOfflineThreadingID()),
+        tasks: [{
+          failure_count: null,
+          label: "100003",
+          payload: JSON.stringify({
+            thread_key: String(threadID),
+            custom_emoji: emoji,
+            avatar_sticker_instruction_key_id: null,
+            sync_group: 1
+          }),
+          queue_name: "thread_quick_reaction",
+          task_id: taskID
+        }],
+        version_id: "24631415369801570"
+      }),
+      request_id: reqID,
+      type: 3
+    });
+
+    ctx.mqttClient.publish("/ls_req", context, { qos: 1, retain: false }, (err) => {
+      if (err) return reject(err);
+      resolve({
+        type: "thread_emoji_update",
+        threadID,
+        newEmoji: emoji,
+        senderID: initiatorID,
+        BotID: ctx.userID,
+        timestamp: Date.now(),
+        method: "mqtt"
+      });
+    });
+  });
+}
+
+async function httpSetEmoji(defaultFuncs, ctx, emoji, threadID, initiatorID) {
+  const form = {
+    emoji_choice: emoji,
+    thread_or_other_fbid: threadID
+  };
+  const res = await defaultFuncs.post(
+    "https://www.facebook.com/messaging/save_thread_emoji/?source=thread_settings&__pc=EXP1%3Amessengerdotcom_pkg",
+    ctx.jar, form
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  if (res.error === 1357031) throw { error: "Thread has no messages yet. Send a message first." };
+  if (res.error) throw res;
+  return {
+    type: "thread_emoji_update",
+    threadID,
+    newEmoji: emoji,
+    senderID: initiatorID,
+    BotID: ctx.userID,
+    timestamp: Date.now(),
+    method: "http"
+  };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return function emojiSet(emoji, threadID, callback, initiatorID) {
+    let _callback, _initiatorID;
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    const type = utils.getType(callback);
+    if (type === "Function" || type === "AsyncFunction") {
+      _callback = callback;
+      _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+      _callback = threadID;
+      threadID = null;
+      _initiatorID = callback;
+    } else if (type === "String") {
+      _initiatorID = callback;
+      _callback = undefined;
+    }
+
+    if (typeof _callback !== "function") {
+      _callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    } else {
+      const orig = _callback;
+      _callback = (err, data) => {
+        orig(err, data);
+        if (err) rejectFunc(err); else resolveFunc(data);
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+    threadID = threadID || ctx.threadID;
+
+    if (!emoji) return _callback(new Error("emoji: emoji character is required")), returnPromise;
+    if (!threadID) return _callback(new Error("emoji: threadID is required")), returnPromise;
+
+    (async () => {
+      try {
+        await globalShield.addSmartDelay();
+        let result;
+        if (ctx.mqttClient) {
+          try {
+            result = await retryOp(() => mqttSetEmoji(ctx, emoji, threadID, _initiatorID));
+          } catch (mqttErr) {
+            utils.warn("emoji", "MQTT failed, using HTTP:", mqttErr.message);
+            result = await retryOp(() => httpSetEmoji(defaultFuncs, ctx, emoji, threadID, _initiatorID));
+          }
+        } else {
+          result = await retryOp(() => httpSetEmoji(defaultFuncs, ctx, emoji, threadID, _initiatorID));
+        }
+        _callback(null, result);
+      } catch (err) {
+        utils.error("emoji", err);
+        _callback(err);
+      }
+    })();
+
+    return returnPromise;
+  };
+};