fca-riyad 37.0.0

package/src/api/socket/e2ee/vendor/proto/WACommon.proto

@@ -0,0 +1,66 @@
+syntax = "proto2";
+package WACommon;
+
+enum FutureProofBehavior {
+	PLACEHOLDER = 0;
+	NO_PLACEHOLDER = 1;
+	IGNORE = 2;
+}
+
+message MessageKey {
+	optional string remoteJID = 1;
+	optional bool fromMe = 2;
+	optional string ID = 3;
+	optional string participant = 4;
+}
+
+message Command {
+	enum CommandType {
+		EVERYONE = 1;
+		SILENT = 2;
+		AI = 3;
+		AI_IMAGINE = 4;
+	}
+
+	optional CommandType commandType = 1;
+	optional uint32 offset = 2;
+	optional uint32 length = 3;
+	optional string validationToken = 4;
+}
+
+message Mention {
+	enum MentionType {
+		PROFILE = 0;
+	}
+
+	optional MentionType mentionType = 1;
+	optional string mentionedJID = 2;
+	optional uint32 offset = 3;
+	optional uint32 length = 4;
+}
+
+message MessageText {
+	optional string text = 1;
+	repeated string mentionedJID = 2;
+	repeated Command commands = 3;
+	repeated Mention mentions = 4;
+}
+
+message SubProtocol {
+	optional bytes payload = 1;
+	optional int32 version = 2;
+}
+
+message LimitSharing {
+	enum Trigger {
+		UNKNOWN = 0;
+		CHAT_SETTING = 1;
+		BIZ_SUPPORTS_FB_HOSTING = 2;
+		UNKNOWN_GROUP = 3;
+	}
+
+	optional bool sharingLimited = 1;
+	optional Trigger trigger = 2;
+	optional int64 limitSharingSettingTimestamp = 3;
+	optional bool initiatedByMe = 4;
+}

package/src/api/socket/e2ee/vendor/proto/WAMediaTransport.proto

@@ -0,0 +1,176 @@
+syntax = "proto2";
+package WAMediaTransport;
+
+import "WACommon.proto";
+
+message WAMediaTransport {
+  message Ancillary {
+    message Thumbnail {
+      message DownloadableThumbnail {
+        optional bytes fileSHA256 = 1;
+        optional bytes fileEncSHA256 = 2;
+        optional string directPath = 3;
+        optional bytes mediaKey = 4;
+        optional int64 mediaKeyTimestamp = 5;
+        optional string objectID = 6;
+        optional bytes thumbnailScansSidecar = 7;
+        repeated uint32 thumbnailScanLengths = 8;
+      }
+
+      optional bytes JPEGThumbnail = 1;
+      optional DownloadableThumbnail downloadableThumbnail = 2;
+      optional uint32 thumbnailWidth = 3;
+      optional uint32 thumbnailHeight = 4;
+    }
+
+    optional uint64 fileLength = 1;
+    optional string mimetype = 2;
+    optional Thumbnail thumbnail = 3;
+    optional string objectID = 4;
+  }
+
+  message Integral {
+    optional bytes fileSHA256 = 1;
+    optional bytes mediaKey = 2;
+    optional bytes fileEncSHA256 = 3;
+    optional string directPath = 4;
+    optional int64 mediaKeyTimestamp = 5;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message ImageTransport {
+  message Ancillary {
+    enum HdType {
+      NONE = 0;
+      LQ_4K = 1;
+      HQ_4K = 2;
+    }
+
+    optional uint32 height = 1;
+    optional uint32 width = 2;
+    optional bytes scansSidecar = 3;
+    repeated uint32 scanLengths = 4;
+    optional bytes midQualityFileSHA256 = 5;
+    optional HdType hdType = 6;
+    repeated float memoriesConceptScores = 7 [packed=true];
+    repeated uint32 memoriesConceptIDs = 8 [packed=true];
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message VideoTransport {
+  message Ancillary {
+    enum Attribution {
+      NONE = 0;
+      GIPHY = 1;
+      TENOR = 2;
+    }
+
+    optional uint32 seconds = 1;
+    optional WACommon.MessageText caption = 2;
+    optional bool gifPlayback = 3;
+    optional uint32 height = 4;
+    optional uint32 width = 5;
+    optional bytes sidecar = 6;
+    optional Attribution gifAttribution = 7;
+    optional string accessibilityLabel = 8;
+    optional bool isHd = 9;
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message AudioTransport {
+  message Ancillary {
+    message AvatarAudio {
+      enum AnimationsType {
+        TALKING_A = 0;
+        IDLE_A = 1;
+        TALKING_B = 2;
+        IDLE_B = 3;
+        BACKGROUND = 4;
+      }
+
+      message DownloadableAvatarAnimations {
+        optional bytes fileSHA256 = 1;
+        optional bytes fileEncSHA256 = 2;
+        optional string directPath = 3;
+        optional bytes mediaKey = 4;
+        optional int64 mediaKeyTimestamp = 5;
+        optional string objectID = 6;
+        optional AnimationsType animationsType = 7;
+      }
+
+      optional uint32 poseID = 1;
+      repeated DownloadableAvatarAnimations avatarAnimations = 2;
+    }
+
+    optional uint32 seconds = 1;
+    optional AvatarAudio avatarAudio = 2;
+    optional string waveformData = 3;
+    optional bytes waveform = 4;
+  }
+
+  message Integral {
+    enum AudioFormat {
+      UNKNOWN = 0;
+      OPUS = 1;
+    }
+
+    optional WAMediaTransport transport = 1;
+    optional AudioFormat audioFormat = 2;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message DocumentTransport {
+  message Ancillary {
+    optional uint32 pageCount = 1;
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message StickerTransport {
+  message Ancillary {
+    optional uint32 pageCount = 1;
+    optional uint32 height = 2;
+    optional uint32 width = 3;
+    optional uint32 firstFrameLength = 4;
+    optional bytes firstFrameSidecar = 5;
+    optional string mustacheText = 6;
+    optional bool isThirdParty = 7;
+    optional string receiverFetchID = 8;
+    optional string accessibilityLabel = 9;
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+    optional bool isAnimated = 2;
+    optional string receiverFetchID = 3;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}

package/src/api/socket/e2ee/vendor/proto/proto-writer.ts

@@ -0,0 +1,76 @@
+/** Minimal protobuf writer - only what we need */
+export class ProtoWriter {
+  private chunks: Buffer[] = [];
+
+  private encodeVarint(value: number): Buffer {
+    const bytes: number[] = [];
+    let v = value >>> 0;
+    while (v > 127) {
+      bytes.push((v & 0x7f) | 0x80);
+      v >>>= 7;
+    }
+    bytes.push(v);
+    return Buffer.from(bytes);
+  }
+
+  private fieldHeader(fieldNum: number, wireType: number): Buffer {
+    return this.encodeVarint((fieldNum << 3) | wireType);
+  }
+
+  /** Wire type 0 (varint) but supports bigint */
+  private encodeVarintBigInt(value: bigint): Buffer {
+    const bytes: number[] = [];
+    let v = value;
+    while (v > 127n) {
+      bytes.push(Number((v & 0x7fn) | 0x80n));
+      v >>= 7n;
+    }
+    bytes.push(Number(v));
+    return Buffer.from(bytes);
+  }
+
+  /** Wire type 0 (varint) for uint64 fields */
+  uint64_varint(fieldNum: number, value: bigint): this {
+    this.chunks.push(this.fieldHeader(fieldNum, 0));
+    this.chunks.push(this.encodeVarintBigInt(value));
+    return this;
+  }
+
+  /** Wire type 2 (length-delimited) - bytes, string, embedded message */
+  bytes(fieldNum: number, data: Uint8Array): this {
+    const d = Buffer.from(data);
+    this.chunks.push(this.fieldHeader(fieldNum, 2));
+    this.chunks.push(this.encodeVarint(d.length));
+    this.chunks.push(d);
+    return this;
+  }
+
+  string(fieldNum: number, value: string): this {
+    return this.bytes(fieldNum, Buffer.from(value, "utf8"));
+  }
+
+  /** Wire type 0 (varint) */
+  varint(fieldNum: number, value: number): this {
+    this.chunks.push(this.fieldHeader(fieldNum, 0));
+    this.chunks.push(this.encodeVarint(value));
+    return this;
+  }
+
+  /** Wire type 0, bool */
+  bool(fieldNum: number, value: boolean): this {
+    return this.varint(fieldNum, value ? 1 : 0);
+  }
+
+  /** Wire type 1 (64-bit fixed) - uint64 */
+  uint64(fieldNum: number, value: bigint): this {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64LE(value);
+    this.chunks.push(this.fieldHeader(fieldNum, 1));
+    this.chunks.push(buf);
+    return this;
+  }
+
+  build(): Buffer {
+    return Buffer.concat(this.chunks);
+  }
+}

package/src/api/socket/listenE2EE.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var logger = require("../../utils/nexca-logger");
+var EventEmitter = require("events");
+
+/**
+ * listenE2EE — merges E2EE messages into the same event stream as MQTT.
+ *
+ * Usage (identical to api.listen):
+ *   api.listenE2EE(callback)   // Node-style callback(err, event)
+ *   api.listenE2EE()           // returns MessageEmitter
+ *
+ * Combines:
+ *   - Regular MQTT messages    (from api.listenMqtt)
+ *   - E2EE encrypted messages  (received via NEXCA native Noise WebSocket)
+ *
+ * All events share the same shape (type, senderID, threadID, body, etc.),
+ * with E2EE events carrying `isE2EE: true`.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+    return function listenE2EE(callback) {
+        class CombinedEmitter extends EventEmitter {
+            stopListening(cb) {
+                if (api._mqttEmitter && typeof api._mqttEmitter.stopListening === "function") {
+                    api._mqttEmitter.stopListening(cb);
+                } else if (typeof cb === "function") {
+                    cb([]);
+                }
+                if (ctx.e2ee && ctx.e2ee.connected) {
+                    ctx.e2ee.disconnect().catch(() => {});
+                }
+            }
+            stopListeningAsync() {
+                return new Promise(res => this.stopListening(res));
+            }
+        }
+
+        var emitter = new CombinedEmitter();
+
+        var isCallbackMode = typeof callback === "function";
+        var globalCallback = isCallbackMode ? callback : function (err, event) {
+            if (err) return emitter.emit("error", err);
+            emitter.emit("message", event);
+        };
+
+// Start regular MQTT listener
+        var mqttEmitter = (api._listenMqttRaw || api.listenMqtt)(globalCallback);
+        api._mqttEmitter = mqttEmitter;
+
+// Hook E2EE incoming messages (NEXCA native Noise WebSocket)
+        var e2ee = api.e2ee || ctx.e2ee;
+        if (!e2ee || !e2ee.isConnected()) {
+            logger.warn(
+                "listenE2EE",
+                "E2EE not connected. E2EE messages will not be received. " +
+                "Call api.connectE2EE() before listenE2EE() to enable encrypted message reception."
+            );
+        } else {
+            e2ee.onMessage(function (err, event) {
+                if (err) return globalCallback(err, null);
+                if (!event) return;
+
+                // Filter self-messages unless selfListen is enabled
+                if (!ctx.globalOptions.selfListen && event.senderID === ctx.userID) return;
+
+                event.isE2EE = true;
+                globalCallback(null, event);
+            });
+
+            logger.success("listenE2EE", "Combined MQTT + E2EE (Signal/Noise) listener active.");
+        }
+
+        return emitter;
+    };
+};