fb-messenger-e2ee 0.1.0 → 0.1.2

package/tests/unit/e2ee/application-helpers.test.ts

@@ -1,418 +0,0 @@
-import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
-import {
-  buildParticipantListHash,
-  normalizeDMThreadToJid,
-  parseMessengerJid,
-  sameMessengerDevice,
-  sameMessengerUser,
-  toADString,
-  toBareMessengerJid,
-  uniqueJids,
-} from "../../../src/e2ee/application/fanout-planner.ts";
-import { OutboundMessageCache, type RecentE2EEOutgoing } from "../../../src/e2ee/application/outbound-message-cache.ts";
-import { PreKeyMaintenance } from "../../../src/e2ee/application/prekey-maintenance.ts";
-import { E2EERetryManager } from "../../../src/e2ee/application/retry-manager.ts";
-import { unmarshal, type Node } from "../../../src/e2ee/transport/binary/wa-binary.ts";
-
-const makeOutgoing = (overrides: Partial<RecentE2EEOutgoing> = {}): RecentE2EEOutgoing => ({
-  kind: "dm",
-  chatJid: "200.0@msgr",
-  messageId: "m1",
-  messageType: "text",
-  messageApp: Buffer.from("message-app"),
-  frankingTag: Buffer.from("franking-tag"),
-  createdAtMs: 1_000,
-  ...overrides,
-});
-
-const findChild = (node: Node, tag: string): Node | undefined => {
-  const children = Array.isArray(node.content) ? node.content as Node[] : [];
-  return children.find((child) => child.tag === tag);
-};
-
-describe("E2EE application helpers", () => {
-  let logSpy: jest.SpiedFunction<typeof console.log>;
-
-  beforeEach(() => {
-    logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
-  });
-
-  afterEach(() => {
-    logSpy.mockRestore();
-  });
-
-  describe("fanout-planner", () => {
-    it("normalizes Messenger device JIDs to stable bare DM chat JIDs", () => {
-      expect(normalizeDMThreadToJid("100042415119261")).toBe("100042415119261.0@msgr");
-      expect(normalizeDMThreadToJid("100042415119261.160@msgr")).toBe("100042415119261.0@msgr");
-      expect(toBareMessengerJid("100042415119261:160@msgr")).toBe("100042415119261.0@msgr");
-    });
-
-    it("parses dot, colon, and AD-style Messenger device identifiers", () => {
-      expect(parseMessengerJid("100.160@msgr")).toMatchObject({ user: "100", device: 160, server: "msgr" });
-      expect(parseMessengerJid("100:160@msgr")).toMatchObject({ user: "100", device: 160, server: "msgr" });
-      expect(parseMessengerJid("100.0:160@msgr")).toMatchObject({ user: "100", device: 160, server: "msgr" });
-      expect(toADString("100.160@msgr")).toBe("100.0:160@msgr");
-    });
-
-    it("deduplicates devices by Messenger user and device while preserving first occurrence", () => {
-      expect(uniqueJids(["100.1@msgr", "100:1@msgr", "100.2@msgr", "200.1@msgr"])).toEqual([
-        "100.1@msgr",
-        "100.2@msgr",
-        "200.1@msgr",
-      ]);
-      expect(sameMessengerUser("100.1@msgr", "100.2@msgr")).toBe(true);
-      expect(sameMessengerDevice("100.1@msgr", "100:1@msgr")).toBe(true);
-      expect(sameMessengerDevice("100.1@msgr", "100.2@msgr")).toBe(false);
-    });
-
-    it("builds participant hashes independent of input order and JID separator style", () => {
-      const hashA = buildParticipantListHash(["200.2@msgr", "100.1@msgr"]);
-      const hashB = buildParticipantListHash(["100:1@msgr", "200:2@msgr"]);
-
-      expect(hashA).toBe(hashB);
-      expect(hashA).toMatch(/^2:[A-Za-z0-9+/]{8}$/);
-    });
-  });
-
-  describe("OutboundMessageCache", () => {
-    it("returns remembered records and prunes expired entries", () => {
-      const nowMs = Date.now();
-      const cache = new OutboundMessageCache({ ttlMs: 100, maxEntries: 10 });
-      cache.remember(makeOutgoing({ messageId: "fresh", createdAtMs: nowMs }));
-      cache.remember(makeOutgoing({ messageId: "old", createdAtMs: nowMs - 200 }));
-
-      cache.prune(nowMs + 1);
-      expect(cache.get("fresh")?.messageId).toBe("fresh");
-      cache.prune(nowMs + 1);
-      expect(cache.get("old")).toBeUndefined();
-    });
-
-    it("keeps only the newest records when maxEntries is exceeded", () => {
-      const nowMs = Date.now();
-      const cache = new OutboundMessageCache({ ttlMs: 10_000, maxEntries: 2 });
-      cache.remember(makeOutgoing({ messageId: "m1", createdAtMs: nowMs }));
-      cache.remember(makeOutgoing({ messageId: "m2", createdAtMs: nowMs }));
-      cache.remember(makeOutgoing({ messageId: "m3", createdAtMs: nowMs }));
-
-      expect(cache.get("m1")).toBeUndefined();
-      expect(cache.get("m2")?.messageId).toBe("m2");
-      expect(cache.get("m3")?.messageId).toBe("m3");
-
-      cache.clear();
-      expect(cache.get("m2")).toBeUndefined();
-    });
-  });
-
-  describe("PreKeyMaintenance", () => {
-    const oldEnv = process.env;
-
-    beforeEach(() => {
-      process.env = { ...oldEnv, FB_E2EE_PREKEY_MIN_COUNT: "5", FB_E2EE_PREKEY_UPLOAD_COUNT: "9" };
-    });
-
-    afterEach(() => {
-      process.env = oldEnv;
-      jest.useRealTimers();
-    });
-
-    it("uploads fresh prekeys when server count is below threshold", async () => {
-      const uploadPreKeys = jest.fn<(count: number) => Promise<void>>().mockResolvedValue(undefined);
-      const maintenance = new PreKeyMaintenance({
-        getSocket: () => ({}),
-        getStore: () => ({}),
-        getServerPreKeyCount: jest.fn<() => Promise<number>>().mockResolvedValue(4),
-        uploadPreKeys,
-      });
-
-      await maintenance.sync("test");
-
-      expect(uploadPreKeys).toHaveBeenCalledWith(9);
-    });
-
-    it("does not upload when disconnected or when server count is healthy", async () => {
-      const uploadPreKeys = jest.fn<(count: number) => Promise<void>>().mockResolvedValue(undefined);
-      const disconnected = new PreKeyMaintenance({
-        getSocket: () => null,
-        getStore: () => ({}),
-        getServerPreKeyCount: jest.fn<() => Promise<number>>().mockResolvedValue(0),
-        uploadPreKeys,
-      });
-      await disconnected.sync("disconnected");
-
-      const healthy = new PreKeyMaintenance({
-        getSocket: () => ({}),
-        getStore: () => ({}),
-        getServerPreKeyCount: jest.fn<() => Promise<number>>().mockResolvedValue(5),
-        uploadPreKeys,
-      });
-      await healthy.sync("healthy");
-
-      expect(uploadPreKeys).not.toHaveBeenCalled();
-    });
-
-
-    it("starts periodic sync and stop cancels the interval", async () => {
-      jest.useFakeTimers();
-      process.env.FB_E2EE_PREKEY_SYNC_INTERVAL_MS = "100";
-      const getServerPreKeyCount = jest.fn<() => Promise<number>>().mockResolvedValue(5);
-      const maintenance = new PreKeyMaintenance({
-        getSocket: () => ({}),
-        getStore: () => ({}),
-        getServerPreKeyCount,
-        uploadPreKeys: jest.fn<(count: number) => Promise<void>>().mockResolvedValue(undefined),
-      });
-      try {
-        maintenance.start();
-        await jest.advanceTimersByTimeAsync(100);
-        expect(getServerPreKeyCount).toHaveBeenCalledTimes(1);
-
-        maintenance.stop();
-        await jest.advanceTimersByTimeAsync(100);
-        expect(getServerPreKeyCount).toHaveBeenCalledTimes(1);
-      } finally {
-        maintenance.stop();
-      }
-    });
-
-    it("does not start periodic sync when interval is disabled", async () => {
-      jest.useFakeTimers();
-      process.env.FB_E2EE_PREKEY_SYNC_INTERVAL_MS = "0";
-      const getServerPreKeyCount = jest.fn<() => Promise<number>>().mockResolvedValue(0);
-      const maintenance = new PreKeyMaintenance({
-        getSocket: () => ({}),
-        getStore: () => ({}),
-        getServerPreKeyCount,
-        uploadPreKeys: jest.fn<(count: number) => Promise<void>>().mockResolvedValue(undefined),
-      });
-
-      maintenance.start();
-      await jest.advanceTimersByTimeAsync(1_000);
-
-      expect(getServerPreKeyCount).not.toHaveBeenCalled();
-    });
-
-    it("swallows sync errors after logging them", async () => {
-      const errorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
-      const maintenance = new PreKeyMaintenance({
-        getSocket: () => ({}),
-        getStore: () => ({}),
-        getServerPreKeyCount: jest.fn<() => Promise<number>>().mockRejectedValue(new Error("count failed")),
-        uploadPreKeys: jest.fn<(count: number) => Promise<void>>().mockResolvedValue(undefined),
-      });
-
-      try {
-        await expect(maintenance.sync("manual")).resolves.toBeUndefined();
-        expect(errorSpy).toHaveBeenCalledWith(
-          "PreKeyMaintenance",
-          expect.stringContaining("Prekey sync failed (manual)"),
-          expect.any(Error),
-        );
-      } finally {
-        errorSpy.mockRestore();
-      }
-    });
-
-  });
-
-  describe("E2EERetryManager", () => {
-    it("re-encrypts cached DM messages to the requesting device", async () => {
-      const cache = new OutboundMessageCache({ ttlMs: 10_000 });
-      cache.remember(makeOutgoing({ messageId: "dm-1", chatJid: "200.0@msgr", createdAtMs: Date.now() }));
-      const socket = { sendFrame: jest.fn<(count: number) => Promise<void>>().mockResolvedValue(undefined) };
-      const client = {
-        hasSession: jest.fn<() => Promise<boolean>>().mockResolvedValue(true),
-        encryptMessageAppForDevice: jest.fn<(recipientJid: string, selfJid: string, messageApp: Buffer, opts?: any) => Promise<{ type: "msg"; ciphertext: Buffer }>>()
-          .mockResolvedValue({ type: "msg", ciphertext: Buffer.from("cipher") }),
-      };
-      const manager = new E2EERetryManager({
-        cache,
-        getClient: () => client as any,
-        getSocket: () => socket as any,
-        getSelfJid: () => "100.5@msgr",
-        getPreKeyBundle: jest.fn() as any,
-      });
-
-      await manager.handleReceipt({
-        tag: "receipt",
-        attrs: { id: "dm-1", from: "200.9@msgr" },
-        content: [{ tag: "retry", attrs: { id: "dm-1", count: "2", t: "123" } }],
-      } as any);
-
-      expect(client.encryptMessageAppForDevice).toHaveBeenCalledWith(
-        "200.9@msgr",
-        "100.5@msgr",
-        Buffer.from("message-app"),
-        { dsm: undefined },
-      );
-      expect(socket.sendFrame).toHaveBeenCalledTimes(1);
-      const sent = unmarshal((socket.sendFrame as any).mock.calls[0][0]);
-      expect(sent.attrs).toMatchObject({ to: "200.0@msgr", id: "dm-1", t: "123", device_fanout: "false" });
-      expect(findChild(sent, "enc")?.attrs).toMatchObject({ type: "msg", count: "2" });
-    });
-
-    it("resends group messages with a fresh SKDM and backup directive", async () => {
-      const cache = new OutboundMessageCache({ ttlMs: 10_000 });
-      cache.remember(makeOutgoing({ kind: "group", messageId: "g-1", chatJid: "180@g.us", createdAtMs: Date.now() }));
-      const socket = { sendFrame: jest.fn<(count: number) => Promise<void>>().mockResolvedValue(undefined) };
-      const skdm = { groupId: "180@g.us", skdmBytes: Buffer.from("skdm"), distributionId: "dist" };
-      const client = {
-        hasSession: jest.fn<() => Promise<boolean>>().mockResolvedValue(true),
-        createSenderKeyDistributionPayload: jest.fn<(groupJid: string, selfJid: string) => Promise<typeof skdm>>().mockResolvedValue(skdm),
-        encryptMessageAppForDevice: jest.fn<(recipientJid: string, selfJid: string, messageApp: Buffer, opts?: any) => Promise<{ type: "pkmsg"; ciphertext: Buffer }>>()
-          .mockResolvedValue({ type: "pkmsg", ciphertext: Buffer.from("cipher") }),
-      };
-      const manager = new E2EERetryManager({
-        cache,
-        getClient: () => client as any,
-        getSocket: () => socket as any,
-        getSelfJid: () => "100.5@msgr",
-        getPreKeyBundle: jest.fn() as any,
-      });
-
-      await manager.handleReceipt({
-        tag: "receipt",
-        attrs: { id: "g-1", participant: "200.9@msgr" },
-        content: [{ tag: "retry", attrs: { id: "g-1", count: "1" } }],
-      } as any);
-
-      expect(client.createSenderKeyDistributionPayload).toHaveBeenCalledWith("180@g.us", "100.5@msgr");
-      expect(client.encryptMessageAppForDevice).toHaveBeenCalledWith(
-        "200.9@msgr",
-        "100.5@msgr",
-        Buffer.from("message-app"),
-        { skdm, backupDirective: { messageId: "g-1", actionType: "UPSERT" } },
-      );
-      const sent = unmarshal((socket.sendFrame as any).mock.calls[0][0]);
-      expect(sent.attrs).toMatchObject({ to: "180@g.us", participant: "200.9@msgr", id: "g-1" });
-      expect(findChild(sent, "enc")?.attrs).toMatchObject({ type: "pkmsg", count: "1" });
-    });
-
-    it("establishes a session from retry receipt keys before resending", async () => {
-      const cache = new OutboundMessageCache({ ttlMs: 10_000 });
-      cache.remember(makeOutgoing({ messageId: "dm-keys", chatJid: "200.0@msgr", createdAtMs: Date.now() }));
-      const socket = { sendFrame: jest.fn<(frame: Buffer) => Promise<void>>().mockResolvedValue(undefined) };
-      const client = {
-        establishSession: jest.fn<(jid: string, bundle: any) => Promise<void>>().mockResolvedValue(undefined),
-        hasSession: jest.fn<() => Promise<boolean>>().mockResolvedValue(false),
-        encryptMessageAppForDevice: jest.fn<(recipientJid: string, selfJid: string, messageApp: Buffer, opts?: any) => Promise<{ type: "msg"; ciphertext: Buffer }>>()
-          .mockResolvedValue({ type: "msg", ciphertext: Buffer.from("cipher") }),
-      };
-      const getPreKeyBundle = jest.fn<() => Promise<any>>().mockResolvedValue({});
-      const manager = new E2EERetryManager({
-        cache,
-        getClient: () => client as any,
-        getSocket: () => socket as any,
-        getSelfJid: () => "100.5@msgr",
-        getPreKeyBundle,
-      });
-      const registration = Buffer.alloc(4);
-      registration.writeUInt32BE(0x01020304);
-
-      await manager.handleReceipt({
-        tag: "receipt",
-        attrs: { id: "dm-keys", from: "200.9@msgr" },
-        content: [
-          { tag: "retry", attrs: { id: "dm-keys", count: "1" } },
-          { tag: "registration", attrs: {}, content: registration },
-          {
-            tag: "keys",
-            attrs: {},
-            content: [
-              { tag: "identity", attrs: {}, content: Buffer.alloc(32, 1) },
-              { tag: "key", attrs: {}, content: [
-                { tag: "id", attrs: {}, content: Buffer.from([0, 0, 7]) },
-                { tag: "value", attrs: {}, content: Buffer.alloc(32, 2) },
-              ] },
-              { tag: "skey", attrs: {}, content: [
-                { tag: "id", attrs: {}, content: Buffer.from([0, 0, 8]) },
-                { tag: "value", attrs: {}, content: Buffer.alloc(32, 3) },
-                { tag: "signature", attrs: {}, content: Buffer.alloc(64, 4) },
-              ] },
-            ],
-          },
-        ],
-      } as any);
-
-      expect(client.establishSession).toHaveBeenCalledWith("200.9@msgr", {
-        registrationId: 0x01020304,
-        deviceId: 9,
-        identityKey: Buffer.concat([Buffer.from([5]), Buffer.alloc(32, 1)]),
-        signedPreKey: {
-          keyId: 8,
-          publicKey: Buffer.concat([Buffer.from([5]), Buffer.alloc(32, 3)]),
-          signature: Buffer.alloc(64, 4),
-        },
-        preKey: {
-          keyId: 7,
-          publicKey: Buffer.concat([Buffer.from([5]), Buffer.alloc(32, 2)]),
-        },
-      });
-      expect(client.hasSession).not.toHaveBeenCalled();
-      expect(getPreKeyBundle).not.toHaveBeenCalled();
-      expect(socket.sendFrame).toHaveBeenCalledTimes(1);
-    });
-
-    it("fetches a prekey bundle when no retry keys and no session exist", async () => {
-      const cache = new OutboundMessageCache({ ttlMs: 10_000 });
-      cache.remember(makeOutgoing({ messageId: "dm-fetch", chatJid: "200.0@msgr", createdAtMs: Date.now() }));
-      const socket = { sendFrame: jest.fn<(frame: Buffer) => Promise<void>>().mockResolvedValue(undefined) };
-      const bundle = { registrationId: 1, deviceId: 9, identityKey: Buffer.alloc(33), signedPreKey: { keyId: 1, publicKey: Buffer.alloc(33), signature: Buffer.alloc(64) } };
-      const client = {
-        establishSession: jest.fn<(jid: string, bundle: any) => Promise<void>>().mockResolvedValue(undefined),
-        hasSession: jest.fn<() => Promise<boolean>>().mockResolvedValue(false),
-        encryptMessageAppForDevice: jest.fn<(recipientJid: string, selfJid: string, messageApp: Buffer, opts?: any) => Promise<{ type: "msg"; ciphertext: Buffer }>>()
-          .mockResolvedValue({ type: "msg", ciphertext: Buffer.from("cipher") }),
-      };
-      const getPreKeyBundle = jest.fn<(jid: string) => Promise<any>>().mockResolvedValue(bundle);
-      const manager = new E2EERetryManager({
-        cache,
-        getClient: () => client as any,
-        getSocket: () => socket as any,
-        getSelfJid: () => "100.5@msgr",
-        getPreKeyBundle,
-      });
-
-      await manager.handleReceipt({
-        tag: "receipt",
-        attrs: { id: "dm-fetch", from: "200.9@msgr" },
-        content: [{ tag: "retry", attrs: { id: "dm-fetch", count: "1" } }],
-      } as any);
-
-      expect(getPreKeyBundle).toHaveBeenCalledWith("200.9@msgr");
-      expect(client.establishSession).toHaveBeenCalledWith("200.9@msgr", bundle);
-    });
-
-    it("ignores retry receipts at or above the retry cap", async () => {
-      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
-      const cache = new OutboundMessageCache({ ttlMs: 10_000 });
-      cache.remember(makeOutgoing({ messageId: "dm-cap", createdAtMs: Date.now() }));
-      const socket = { sendFrame: jest.fn<(frame: Buffer) => Promise<void>>().mockResolvedValue(undefined) };
-      const client = {
-        hasSession: jest.fn<() => Promise<boolean>>().mockResolvedValue(true),
-        encryptMessageAppForDevice: jest.fn(),
-      };
-      const manager = new E2EERetryManager({
-        cache,
-        getClient: () => client as any,
-        getSocket: () => socket as any,
-        getSelfJid: () => "100.5@msgr",
-        getPreKeyBundle: jest.fn() as any,
-      });
-
-      try {
-        await manager.handleReceipt({
-          tag: "receipt",
-          attrs: { id: "dm-cap", from: "200.9@msgr" },
-          content: [{ tag: "retry", attrs: { id: "dm-cap", count: "10" } }],
-        } as any);
-
-        expect(client.encryptMessageAppForDevice).not.toHaveBeenCalled();
-        expect(socket.sendFrame).not.toHaveBeenCalled();
-      } finally {
-        warnSpy.mockRestore();
-      }
-    });
-
-  });
-});

package/tests/unit/e2ee/device-store.test.ts

@@ -1,126 +0,0 @@
-import { DeviceStore } from "../../../src/e2ee/store/device-store.ts";
-import { Direction, PrivateKey, ProtocolAddress } from "@signalapp/libsignal-client";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-
-describe("DeviceStore", () => {
-  let store: DeviceStore;
-  let testPath: string;
-
-  beforeEach(async () => {
-    testPath = path.join(os.tmpdir(), `device-${Math.random().toString(36).slice(2)}.json`);
-    store = await DeviceStore.fromFile(testPath);
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(testPath)) {
-      fs.unlinkSync(testPath);
-    }
-  });
-
-  describe("serialization", () => {
-    it("should generate a new device if file missing", () => {
-      expect(store.registrationId).toBeGreaterThan(0);
-      expect(store.noiseKeyPriv).toBeDefined();
-      expect(store.toJSON().schema_version).toBe(1);
-    });
-
-    it("should export to JSON correctly", () => {
-      const json = store.toJSON();
-      expect(json.registration_id).toBe(store.registrationId);
-      expect(json.noise_key_priv).toBe(store.noiseKeyPriv.toString("base64"));
-      expect(json.identities).toEqual({});
-      expect(json.sessions).toEqual({});
-      expect(json.sender_keys).toEqual({});
-    });
-
-    it("should save and reload from file without rotating identity", async () => {
-      const regId = store.registrationId;
-      const identity = store.getIdentityPrivateKey().toString("base64");
-      (store as any).saveToFile();
-
-      const newStore = await DeviceStore.fromFile(testPath);
-      expect(newStore.registrationId).toBe(regId);
-      expect(newStore.getIdentityPrivateKey().toString("base64")).toBe(identity);
-    });
-
-    it("should load old JSON through migration defaults", async () => {
-      const oldJson: any = store.toJSON();
-      delete oldJson.schema_version;
-      delete oldJson.identities;
-      delete oldJson.sessions;
-      delete oldJson.pre_keys;
-      delete oldJson.sender_keys;
-      delete oldJson.signed_pre_keys;
-      delete oldJson.next_pre_key_id;
-
-      const loaded = await DeviceStore.fromData(JSON.stringify(oldJson));
-      expect(loaded.toJSON()).toMatchObject({
-        schema_version: 1,
-        next_pre_key_id: 1,
-        identities: {},
-        sessions: {},
-        pre_keys: {},
-        sender_keys: {},
-        signed_pre_keys: {},
-      });
-    });
-  });
-
-  describe("Messenger JID persistence", () => {
-    it("should parse dot and colon device JIDs and trigger onDataChanged only on changes", async () => {
-      const changes: string[] = [];
-      const memoryStore = await DeviceStore.fromData(store.getData(), json => changes.push(json));
-
-      memoryStore.setJIDs("100042415119261.160@msgr", "");
-      memoryStore.setJIDs("100042415119261.160@msgr", "");
-      expect(memoryStore.jidUser).toBe("100042415119261");
-      expect(memoryStore.jidDevice).toBe(160);
-      expect(changes).toHaveLength(1);
-
-      memoryStore.setJIDs("100042415119261:161@msgr", "");
-      expect(memoryStore.jidDevice).toBe(161);
-      expect(changes).toHaveLength(2);
-      expect(JSON.parse(changes.at(-1)!).jid_device).toBe(161);
-    });
-
-    it("should ignore invalid non-Messenger JIDs", () => {
-      store.setJIDs("100@s.whatsapp.net", "");
-      expect(store.jidUser).toBeUndefined();
-      expect(store.jidDevice).toBeUndefined();
-    });
-  });
-
-  describe("identity and in-memory protocol maps", () => {
-    it("should save identities, detect changes, and enforce trust-on-first-use", async () => {
-      const address = ProtocolAddress.new("1001", 2);
-      const keyA = PrivateKey.generate().getPublicKey();
-      const keyB = PrivateKey.generate().getPublicKey();
-
-      await expect(store.isTrustedIdentity(address, keyA, Direction.Sending)).resolves.toBe(true);
-      await expect(store.saveIdentity(address, keyA)).resolves.toBe(true);
-      await expect(store.saveIdentity(address, keyA)).resolves.toBe(false);
-      await expect(store.isTrustedIdentity(address, keyA, Direction.Sending)).resolves.toBe(true);
-      await expect(store.isTrustedIdentity(address, keyB, Direction.Sending)).resolves.toBe(false);
-      store.autoTrust = true;
-      await expect(store.isTrustedIdentity(address, keyB, Direction.Sending)).resolves.toBe(true);
-    });
-
-    it("should report existing sessions without deserializing unrelated addresses", () => {
-      (store as any).sessions.set("1001.2", Buffer.from("fake-session-record"));
-
-      expect(store.hasSession("1001.2")).toBe(true);
-      expect(store.hasSession("1001.3")).toBe(false);
-    });
-
-    it("should list sender-key distribution IDs for one sender only", () => {
-      const sender = ProtocolAddress.new("1001", 2);
-      (store as any).senderKeys.set("1001.2::dist-a", Buffer.from("a"));
-      (store as any).senderKeys.set("1001.2::dist-b", Buffer.from("b"));
-      (store as any).senderKeys.set("1001.3::dist-c", Buffer.from("c"));
-
-      expect(store.listSenderKeyDistributionIds(sender).sort()).toEqual(["dist-a", "dist-b"]);
-    });
-  });
-});

package/tests/unit/e2ee/facebook-protocol-utils.test.ts

@@ -1,134 +0,0 @@
-import {
-  decodeVarint,
-  encodeVarint,
-  parseFBProtobufSKDM,
-  parseFBProtobufSKMSG,
-  stableDistributionId,
-  uuidParse,
-  uuidStringify,
-  wrapAsSignalSKMSG,
-} from "../../../src/e2ee/facebook/facebook-protocol-utils.ts";
-
-const fieldVarint = (field: number, value: number) => Buffer.concat([
-  encodeVarint((field << 3) | 0),
-  encodeVarint(value),
-]);
-
-const fieldBytes = (field: number, value: Buffer) => Buffer.concat([
-  encodeVarint((field << 3) | 2),
-  encodeVarint(value.length),
-  value,
-]);
-
-describe("facebook-protocol-utils", () => {
-  describe("varint", () => {
-    it.each([0, 1, 127, 128, 150, 255, 16_384, 1_234_567, 0xffffffff])(
-      "round-trips %i",
-      (value) => {
-        const buf = encodeVarint(value);
-        const decoded = decodeVarint(Buffer.concat([Buffer.from([0xaa]), buf]), 1);
-        expect(decoded.value).toBe(value);
-        expect(decoded.length).toBe(buf.length);
-      },
-    );
-
-    it("should throw on unexpected EOF", () => {
-      const buf = Buffer.from([0x80, 0x80]);
-      expect(() => decodeVarint(buf, 0)).toThrow("Unexpected EOF in varint");
-    });
-
-    it("should throw on overlong varints", () => {
-      expect(() => decodeVarint(Buffer.alloc(11, 0x80), 0)).toThrow("Varint too long");
-    });
-  });
-
-  describe("uuid", () => {
-    it("should stringify and parse UUIDs correctly", () => {
-      const original = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-      const buf = uuidParse(original);
-      expect(buf.length).toBe(16);
-      const str = uuidStringify(buf);
-      expect(str).toBe(original);
-    });
-
-    it("stableDistributionId should be deterministic and look like a v4 UUID", () => {
-      const group = "12345@g.us";
-      const sender = "67890@s.whatsapp.net";
-      const id1 = stableDistributionId(group, sender);
-      const id2 = stableDistributionId(group, sender);
-      const other = stableDistributionId(group, "11111@s.whatsapp.net");
-
-      expect(id1).toBe(id2);
-      expect(id1).not.toBe(other);
-      expect(id1).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
-    });
-  });
-
-  describe("Facebook protobuf SKMSG/SKDM", () => {
-    it("parses SKMSG and skips unknown varint/bytes fields", () => {
-      const ciphertext = Buffer.from("ciphertext");
-      const encoded = Buffer.concat([
-        fieldVarint(9, 1),
-        fieldBytes(10, Buffer.from("skip")),
-        fieldVarint(1, 42),
-        fieldVarint(2, 7),
-        fieldBytes(3, ciphertext),
-      ]);
-
-      expect(parseFBProtobufSKMSG(encoded)).toEqual({
-        id: 42,
-        iteration: 7,
-        ciphertext,
-      });
-    });
-
-    it("returns null for malformed SKMSG length prefixes", () => {
-      expect(parseFBProtobufSKMSG(Buffer.from([0x1a, 0x80]))).toBeNull();
-    });
-
-    it("parses SKDM with optional signing public key", () => {
-      const chainKey = Buffer.alloc(32, 1);
-      const signingPublicKey = Buffer.alloc(33, 2);
-      const encoded = Buffer.concat([
-        fieldVarint(1, 123),
-        fieldVarint(2, 456),
-        fieldBytes(3, chainKey),
-        fieldBytes(4, signingPublicKey),
-        fieldBytes(12, Buffer.from("unknown")),
-      ]);
-
-      expect(parseFBProtobufSKDM(encoded)).toEqual({
-        chainId: 123,
-        iteration: 456,
-        chainKey,
-        signingPublicKey,
-      });
-    });
-
-    it("returns null for malformed SKDM length prefixes", () => {
-      expect(parseFBProtobufSKDM(Buffer.from([0x1a, 0x80]))).toBeNull();
-    });
-  });
-
-  describe("wrapAsSignalSKMSG", () => {
-    it("wraps FB sender-key message fields and appends deterministic signature", () => {
-      const distributionId = "6ba7b810-9dad-41d1-80b4-00c04fd430c8";
-      const ciphertext = Buffer.from("group-ciphertext");
-      const wrapped = wrapAsSignalSKMSG({
-        distributionId,
-        id: 5,
-        iteration: 9,
-        ciphertext,
-        senderJid: "100.1@msgr",
-      });
-      const signedPayloadLength = 1 + 18 + 2 + 2 + 2 + ciphertext.length;
-
-      expect(wrapped).toHaveLength(signedPayloadLength + 64);
-      expect(wrapped[0]).toBe(0x33);
-      expect(wrapped.subarray(1, 19)).toEqual(Buffer.concat([Buffer.from([0x0a, 0x10]), uuidParse(distributionId)]));
-      expect(wrapped.includes(ciphertext)).toBe(true);
-      expect(wrapped.subarray(0, signedPayloadLength).includes(ciphertext)).toBe(true);
-      expect(wrapped.subarray(signedPayloadLength)).toHaveLength(64);
-    });
-  });
-});