@pontalabs/baileys 1.0.10 → 1.1.0

package/lib/Signal/libsignal.js

@@ -1,285 +1,364 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLibSignalRepository = makeLibSignalRepository;
-const libsignal = __importStar(require("libsignal"));
-const { PreKeyWhisperMessage } = require("libsignal/src/protobufs");
-const Utils_1 = require("../Utils");
-const WABinary_1 = require("../WABinary");
-const sender_key_name_1 = require("./Group/sender-key-name");
-const sender_key_record_1 = require("./Group/sender-key-record");
-const Group_1 = require("./Group");
-const LIDMappingStore_1 = require("./lid-mapping") 
-
-// FIX: sebelumnya pontalabs gak punya deteksi perubahan identity key sama
-// sekali. Kalau identity kontak berubah (kontak install ulang WA, atau kena
-// resync multi-device pas ada linked device lain online), sesi lama tetap
-// dipakai terus dan selalu gagal decrypt "Bad MAC" berulang-ulang sampai
-// akhirnya kena threshold retry enableAutoSessionRecreation. Dengan deteksi
-// ini, begitu identity berubah, sesi langsung direset SAAT ITU JUGA - gak
-// perlu nunggu beberapa pesan gagal dulu.
-function extractIdentityFromPkmsg(ciphertext) {
-    try {
-        if (!ciphertext || ciphertext.length < 2) {
-            return undefined;
-        }
-        const version = ciphertext[0];
-        if ((version & 0xf) !== 3) {
-            return undefined;
-        }
-        const preKeyProto = PreKeyWhisperMessage.decode(ciphertext.slice(1));
-        if (preKeyProto.identityKey && preKeyProto.identityKey.length === 33) {
-            return Buffer.from(preKeyProto.identityKey);
-        }
-        return undefined;
-    } catch {
-        return undefined;
-    }
-}
-
-function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
-	const lidMapping = new LIDMappingStore_1.LIDMappingStore(auth.keys, onWhatsAppFunc, logger)
-    const storage = signalStorage(auth);
-    return {
-        lidMapping,
-        decryptGroupMessage({ group, authorJid, msg }) {
+const {
+    SessionCipher: SessionCipher,
+    SessionBuilder: SessionBuilder,
+    SessionRecord: SessionRecord,
+    ProtocolAddress: ProtocolAddress,
+} = require("libsignal");
+const { generateSignalPubKey: generateSignalPubKey } = require("../Utils");
+const {
+    isHostedLidUser: isHostedLidUser,
+    isHostedPnUser: isHostedPnUser,
+    isLidUser: isLidUser,
+    isPnUser: isPnUser,
+    jidDecode: jidDecode,
+    transferDevice: transferDevice,
+    WAJIDDomains: WAJIDDomains,
+} = require("../WABinary");
+const { SenderKeyName: SenderKeyName } = require("./Group/sender-key-name");
+const { SenderKeyRecord: SenderKeyRecord } = require("./Group/sender-key-record");
+const {
+    GroupCipher: GroupCipher,
+    GroupSessionBuilder: GroupSessionBuilder,
+    SenderKeyDistributionMessage: SenderKeyDistributionMessage,
+} = require("./Group");
+const { LRUCache: LRUCache } = require("lru-cache");
+const { LIDMappingStore: LIDMappingStore } = require("./lid-mapping");
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc);
+    const storage = signalStorage(auth, lidMapping);
+    const parsedKeys = auth.keys;
+    const migratedSessionCache = new LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1e3,
+        ttlAutopurge: true,
+        updateAgeOnGet: true,
+    });
+    const repository = {
+        decryptGroupMessage({ group: group, authorJid: authorJid, msg: msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
-            const cipher = new Group_1.GroupCipher(storage, senderName);
-            // Dibungkus transaction() biar atomic - konsisten sama operasi Signal
-            // lainnya, cegah race condition kalau ada beberapa pesan grup dari
-            // sender yang sama numpuk barengan.
-            return auth.keys.transaction(async () => {
-                return cipher.decrypt(msg);
-            }, group);
+            const cipher = new GroupCipher(storage, senderName);
+            return parsedKeys.transaction(async () => cipher.decrypt(msg), group);
         },
-        async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new Group_1.GroupSessionBuilder(storage);
+        async processSenderKeyDistributionMessage({ item: item, authorJid: authorJid }) {
+            const builder = new GroupSessionBuilder(storage);
             if (!item.groupId) {
-                throw new Error('Group ID is required for sender key distribution message');
+                throw new Error("Group ID is required for sender key distribution message");
             }
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
-            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderMsg = new SenderKeyDistributionMessage(
+                null,
+                null,
+                null,
+                null,
+                item.axolotlSenderKeyDistributionMessage
+            );
             const senderNameStr = senderName.toString();
-            return auth.keys.transaction(async () => {
-                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [
+                senderNameStr,
+            ]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new SenderKeyRecord());
+            }
+            return parsedKeys.transaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [
+                    senderNameStr,
+                ]);
                 if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                    await storage.storeSenderKey(senderName, new SenderKeyRecord());
                 }
                 await builder.process(senderName, senderMsg);
             }, item.groupId);
         },
-        async decryptMessage({ jid, type, ciphertext }) {
+        async decryptMessage({ jid: jid, type: type, ciphertext: ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
-            const session = new libsignal.SessionCipher(storage, addr);
-            // Sebelum decrypt pkmsg (pesan yang buka sesi baru), cek dulu apakah
-            // identity key pengirim berubah dibanding yang tersimpan. Kalau iya,
-            // sesi lama otomatis direset supaya gak nyoba decrypt pakai sesi basi.
-            if (type === 'pkmsg') {
-                const identityKey = extractIdentityFromPkmsg(ciphertext);
-                if (identityKey) {
-                    const addrStr = addr.toString();
-                    const identityChanged = await storage.saveIdentity(addrStr, identityKey);
-                    if (identityChanged) {
-                        logger?.info?.({ jid, addr: addrStr }, 'identity key changed or new contact, session will be re-established');
-                    }
+            const session = new SessionCipher(storage, addr);
+            async function doDecrypt() {
+                let result;
+                switch (type) {
+                    case "pkmsg":
+                        result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                        break;
+                    case "msg":
+                        result = await session.decryptWhisperMessage(ciphertext);
+                        break;
                 }
+                return result;
             }
-            try {
-                return await auth.keys.transaction(async () => {
-                    let result;
-                    switch (type) {
-                        case 'pkmsg':
-                            result = await session.decryptPreKeyWhisperMessage(ciphertext);
-                            break;
-                        case 'msg':
-                            result = await session.decryptWhisperMessage(ciphertext);
-                            break;
-                        default:
-                            throw new Error(`Unknown message type: ${type}`);
-                    }
-                    return result;
-                }, jid);
-            } catch (error) {
-                const errText = String(error?.message || error || '')
-                if (/bad mac|no session|invalid message|duplicate message|cannot decrypt/i.test(errText)) {
-                    await storage.removeSession(addr.toString()).catch(() => null)
-                    logger?.warn?.({ jid, type, errText }, 'reset stale session after decrypt failure')
-                }
-                throw error
-            }
+            return parsedKeys.transaction(async () => await doDecrypt(), jid);
         },
-        async encryptMessage({ jid, data }) {
+        async encryptMessage({ jid: jid, data: data }) {
             const addr = jidToSignalProtocolAddress(jid);
-            const cipher = new libsignal.SessionCipher(storage, addr);
-            return auth.keys.transaction(async () => {
-                const { type: sigType, body } = await cipher.encrypt(data);
-                const type = sigType === 3 ? 'pkmsg' : 'msg';
-                return { type, ciphertext: Buffer.from(body, 'binary') };
+            const cipher = new SessionCipher(storage, addr);
+            return parsedKeys.transaction(async () => {
+                const { type: sigType, body: body } = await cipher.encrypt(data);
+                const type = sigType === 3 ? "pkmsg" : "msg";
+                return { type: type, ciphertext: Buffer.from(body, "binary") };
             }, jid);
         },
-        async encryptGroupMessage({ group, meId, data }) {
-            return auth.keys.transaction(async () => {
-                const senderName = jidToSignalSenderKeyName(group, meId);
-                const builder = new Group_1.GroupSessionBuilder(storage);
-                const senderNameStr = senderName.toString();
-                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+        async encryptGroupMessage({ group: group, meId: meId, data: data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId);
+            const builder = new GroupSessionBuilder(storage);
+            const senderNameStr = senderName.toString();
+            return parsedKeys.transaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [
+                    senderNameStr,
+                ]);
                 if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                    await storage.storeSenderKey(senderName, new SenderKeyRecord());
                 }
                 const senderKeyDistributionMessage = await builder.create(senderName);
-                const session = new Group_1.GroupCipher(storage, senderName);
+                const session = new GroupCipher(storage, senderName);
                 const ciphertext = await session.encrypt(data);
                 return {
-                    ciphertext,
-                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+                    ciphertext: ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
                 };
             }, group);
         },
-        async injectE2ESession({ jid, session }) {
-            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            await cipher.initOutgoing(session);
+        async injectE2ESession({ jid: jid, session: session }) {
+            logger.trace({ jid: jid }, "injecting E2EE session");
+            const cipher = new SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            return parsedKeys.transaction(async () => {
+                await cipher.initOutgoing(session);
+            }, jid);
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
         },
-        // Dipakai oleh sendRetryRequest (messages-recv.js) untuk enableAutoSessionRecreation.
-        // Sebelumnya dipanggil tapi tidak pernah diimplementasikan di sini, jadi fitur auto
-        // session recreation diam-diam selalu gagal (ketangkep try/catch, cuma log warning).
+        lidMapping: lidMapping,
         async validateSession(jid) {
             try {
                 const addr = jidToSignalProtocolAddress(jid);
                 const session = await storage.loadSession(addr.toString());
                 if (!session) {
-                    return { exists: false, reason: 'no session' };
+                    return { exists: false, reason: "no session" };
                 }
-                if (typeof session.haveOpenSession === 'function' && !session.haveOpenSession()) {
-                    return { exists: false, reason: 'no open session' };
+                if (!session.haveOpenSession()) {
+                    return { exists: false, reason: "no open session" };
                 }
                 return { exists: true };
             } catch (error) {
-                return { exists: false, reason: 'validation error' };
+                return { exists: false, reason: "validation error" };
             }
-        }
+        },
+        async deleteSession(jids) {
+            if (!jids.length) return;
+            const sessionUpdates = {};
+            jids.forEach((jid) => {
+                const addr = jidToSignalProtocolAddress(jid);
+                sessionUpdates[addr.toString()] = null;
+            });
+            return parsedKeys.transaction(async () => {
+                await auth.keys.set({ session: sessionUpdates });
+            }, `delete-${jids.length}-sessions`);
+        },
+        async migrateSession(fromJid, toJid) {
+            if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid))) {
+                return { migrated: 0, skipped: 0, total: 0 };
+            }
+            if (!isPnUser(fromJid) && !isHostedPnUser(fromJid)) {
+                return { migrated: 0, skipped: 0, total: 1 };
+            }
+            const { user: user } = jidDecode(fromJid);
+            logger.debug({ fromJid: fromJid }, "bulk device migration - loading all user devices");
+            const { [user]: userDevices } = await parsedKeys.get("device-list", [user]);
+            if (!userDevices) {
+                return { migrated: 0, skipped: 0, total: 0 };
+            }
+            const { device: fromDevice } = jidDecode(fromJid);
+            const fromDeviceStr = fromDevice?.toString() || "0";
+            if (!userDevices.includes(fromDeviceStr)) {
+                userDevices.push(fromDeviceStr);
+            }
+            const uncachedDevices = userDevices.filter((device) => {
+                const deviceKey = `${user}.${device}`;
+                return !migratedSessionCache.has(deviceKey);
+            });
+            const deviceSessionKeys = uncachedDevices.map((device) => `${user}.${device}`);
+            const existingSessions = await parsedKeys.get("session", deviceSessionKeys);
+            const deviceJids = [];
+            for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
+                if (sessionData) {
+                    const deviceStr = sessionKey.split(".")[1];
+                    if (!deviceStr) continue;
+                    const deviceNum = parseInt(deviceStr);
+                    let jid =
+                        deviceNum === 0
+                            ? `${user}@s.whatsapp.net`
+                            : `${user}:${deviceNum}@s.whatsapp.net`;
+                    if (deviceNum === 99) {
+                        jid = `${user}:99@hosted`;
+                    }
+                    deviceJids.push(jid);
+                }
+            }
+            logger.debug(
+                {
+                    fromJid: fromJid,
+                    totalDevices: userDevices.length,
+                    devicesWithSessions: deviceJids.length,
+                    devices: deviceJids,
+                },
+                "bulk device migration complete - all user devices processed"
+            );
+            return parsedKeys.transaction(
+                async () => {
+                    const migrationOps = deviceJids.map((jid) => {
+                        const lidWithDevice = transferDevice(jid, toJid);
+                        const fromDecoded = jidDecode(jid);
+                        const toDecoded = jidDecode(lidWithDevice);
+                        return {
+                            fromJid: jid,
+                            toJid: lidWithDevice,
+                            pnUser: fromDecoded.user,
+                            lidUser: toDecoded.user,
+                            deviceId: fromDecoded.device || 0,
+                            fromAddr: jidToSignalProtocolAddress(jid),
+                            toAddr: jidToSignalProtocolAddress(lidWithDevice),
+                        };
+                    });
+                    const totalOps = migrationOps.length;
+                    let migratedCount = 0;
+                    const pnAddrStrings = Array.from(
+                        new Set(migrationOps.map((op) => op.fromAddr.toString()))
+                    );
+                    const pnSessions = await parsedKeys.get("session", pnAddrStrings);
+                    const sessionUpdates = {};
+                    for (const op of migrationOps) {
+                        const pnAddrStr = op.fromAddr.toString();
+                        const lidAddrStr = op.toAddr.toString();
+                        const pnSession = pnSessions[pnAddrStr];
+                        if (pnSession) {
+                            const fromSession = SessionRecord.deserialize(pnSession);
+                            if (fromSession.haveOpenSession()) {
+                                sessionUpdates[lidAddrStr] = fromSession.serialize();
+                                sessionUpdates[pnAddrStr] = null;
+                                migratedCount++;
+                            }
+                        }
+                    }
+                    if (Object.keys(sessionUpdates).length > 0) {
+                        await parsedKeys.set({ session: sessionUpdates });
+                        logger.debug(
+                            { migratedSessions: migratedCount },
+                            "bulk session migration complete"
+                        );
+                        for (const op of migrationOps) {
+                            if (sessionUpdates[op.toAddr.toString()]) {
+                                const deviceKey = `${op.pnUser}.${op.deviceId}`;
+                                migratedSessionCache.set(deviceKey, true);
+                            }
+                        }
+                    }
+                    const skippedCount = totalOps - migratedCount;
+                    return {
+                        migrated: migratedCount,
+                        skipped: skippedCount,
+                        total: totalOps,
+                    };
+                },
+                `migrate-${deviceJids.length}-sessions-${jidDecode(toJid)?.user}`
+            );
+        },
     };
+    return repository;
 }
 const jidToSignalProtocolAddress = (jid) => {
-    const { user, device } = (0, WABinary_1.jidDecode)(jid);
-    return new libsignal.ProtocolAddress(user, device || 0);
-};
-const jidToSignalSenderKeyName = (group, user) => {
-    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
+    const decoded = jidDecode(jid);
+    const { user: user, device: device, server: server, domainType: domainType } = decoded;
+    if (!user) {
+        throw new Error(
+            `JID decoded but user is empty: "${jid}" -> user: "${user}", server: "${server}", device: ${device}`
+        );
+    }
+    const signalUser = domainType !== WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user;
+    const finalDevice = device || 0;
+    if (device === 99 && decoded.server !== "hosted" && decoded.server !== "hosted.lid") {
+        throw new Error(
+            "Unexpected non-hosted device JID with device 99. This ID seems invalid. ID:" + jid
+        );
+    }
+    return new ProtocolAddress(signalUser, finalDevice);
 };
-function signalStorage({ creds, keys }) {
+const jidToSignalSenderKeyName = (group, user) =>
+    new SenderKeyName(group, jidToSignalProtocolAddress(user));
+function signalStorage({ creds: creds, keys: keys }, lidMapping) {
+    const resolveLIDSignalAddress = async (id) => {
+        if (id.includes(".")) {
+            const [deviceId, device] = id.split(".");
+            const [user, domainType_] = deviceId.split("_");
+            const domainType = parseInt(domainType_ || "0");
+            if (domainType === WAJIDDomains.LID || domainType === WAJIDDomains.HOSTED_LID)
+                return id;
+            const pnJid = `${user}${device !== "0" ? `:${device}` : ""}@${domainType === WAJIDDomains.HOSTED ? "hosted" : "s.whatsapp.net"}`;
+            const lidForPN = await lidMapping.getLIDForPN(pnJid);
+            if (lidForPN) {
+                const lidAddr = jidToSignalProtocolAddress(lidForPN);
+                return lidAddr.toString();
+            }
+        }
+        return id;
+    };
     return {
         loadSession: async (id) => {
-            const { [id]: sess } = await keys.get('session', [id]);
-            if (sess) {
-                return libsignal.SessionRecord.deserialize(sess);
+            try {
+                const wireJid = await resolveLIDSignalAddress(id);
+                const { [wireJid]: sess } = await keys.get("session", [wireJid]);
+                if (sess) {
+                    return SessionRecord.deserialize(sess);
+                }
+            } catch (e) {
+                return null;
             }
+            return null;
         },
         storeSession: async (id, session) => {
-            await keys.set({ session: { [id]: session.serialize() } });
-        },
-        removeSession: async (id) => {
-            await keys.set({ session: { [id]: null } });
-        },
-        isTrustedIdentity: () => {
-            return true;
-        },
-        loadIdentityKey: async (id) => {
-            const { [id]: key } = await keys.get('identity-key', [id]);
-            return key || undefined;
-        },
-        saveIdentity: async (id, identityKey) => {
-            const { [id]: existingKey } = await keys.get('identity-key', [id]);
-            const keysMatch = existingKey && existingKey.length === identityKey.length &&
-                Buffer.compare(Buffer.from(existingKey), Buffer.from(identityKey)) === 0;
-            if (existingKey && !keysMatch) {
-                // Identity berubah - hapus sesi lama (bakal ke-generate ulang dari
-                // pkmsg yang lagi diproses) dan simpan identity key yang baru.
-                await keys.set({
-                    session: { [id]: null },
-                    'identity-key': { [id]: identityKey }
-                });
-                return true;
-            }
-            if (!existingKey) {
-                // Kontak baru - Trust On First Use (TOFU), sama kayak WhatsApp Web.
-                await keys.set({ 'identity-key': { [id]: identityKey } });
-                return true;
-            }
-            return false;
+            const wireJid = await resolveLIDSignalAddress(id);
+            await keys.set({ session: { [wireJid]: session.serialize() } });
         },
+        isTrustedIdentity: () => true,
         loadPreKey: async (id) => {
             const keyId = id.toString();
-            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            const { [keyId]: key } = await keys.get("pre-key", [keyId]);
             if (key) {
                 return {
                     privKey: Buffer.from(key.private),
-                    pubKey: Buffer.from(key.public)
+                    pubKey: Buffer.from(key.public),
                 };
             }
         },
-        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        removePreKey: (id) => keys.set({ "pre-key": { [id]: null } }),
         loadSignedPreKey: () => {
             const key = creds.signedPreKey;
             return {
                 privKey: Buffer.from(key.keyPair.private),
-                pubKey: Buffer.from(key.keyPair.public)
+                pubKey: Buffer.from(key.keyPair.public),
             };
         },
         loadSenderKey: async (senderKeyName) => {
             const keyId = senderKeyName.toString();
-            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            const { [keyId]: key } = await keys.get("sender-key", [keyId]);
             if (key) {
-                return sender_key_record_1.SenderKeyRecord.deserialize(key);
+                return SenderKeyRecord.deserialize(key);
             }
-            return new sender_key_record_1.SenderKeyRecord();
+            return new SenderKeyRecord();
         },
         storeSenderKey: async (senderKeyName, key) => {
             const keyId = senderKeyName.toString();
             const serialized = JSON.stringify(key.serialize());
-            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } });
+            await keys.set({
+                "sender-key": { [keyId]: Buffer.from(serialized, "utf-8") },
+            });
         },
         getOurRegistrationId: () => creds.registrationId,
         getOurIdentity: () => {
-            const { signedIdentityKey } = creds;
+            const { signedIdentityKey: signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
+                pubKey: Buffer.from(generateSignalPubKey(signedIdentityKey.public)),
             };
-        }
+        },
     };
 }
+module.exports = { makeLibSignalRepository: makeLibSignalRepository };