@baileys-md/baileys 10.0.7

package/WASignalGroup/sender_key_state.js

@@ -0,0 +1,129 @@
+const SenderChainKey = require('./sender_chain_key');
+const SenderMessageKey = require('./sender_message_key');
+
+const protobufs = require('./protobufs');
+
+class SenderKeyState {
+    MAX_MESSAGE_KEYS = 2000;
+
+    constructor(
+        id = null,
+        iteration = null,
+        chainKey = null,
+        signatureKeyPair = null,
+        signatureKeyPublic = null,
+        signatureKeyPrivate = null,
+        senderKeyStateStructure = null
+    ) {
+        if (senderKeyStateStructure) {
+            this.senderKeyStateStructure = senderKeyStateStructure;
+        } else {
+            if (signatureKeyPair) {
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
+            }
+
+            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
+            this.senderKeyStateStructure = protobufs.SenderKeyStateStructure.create();
+            const senderChainKeyStructure = protobufs.SenderChainKey.create();
+            senderChainKeyStructure.iteration = iteration;
+            senderChainKeyStructure.seed = chainKey;
+            this.senderKeyStateStructure.senderChainKey = senderChainKeyStructure;
+
+            const signingKeyStructure = protobufs.SenderSigningKey.create();
+            signingKeyStructure.public =
+                typeof signatureKeyPublic === 'string' ?
+                Buffer.from(signatureKeyPublic, 'base64') :
+                signatureKeyPublic;
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ?
+                    Buffer.from(signatureKeyPrivate, 'base64') :
+                    signatureKeyPrivate;
+            }
+            this.senderKeyStateStructure.senderKeyId = id;
+            this.senderChainKey = senderChainKeyStructure;
+            this.senderKeyStateStructure.senderSigningKey = signingKeyStructure;
+        }
+        this.senderKeyStateStructure.senderMessageKeys =
+            this.senderKeyStateStructure.senderMessageKeys || [];
+    }
+
+    SenderKeyState(senderKeyStateStructure) {
+        this.senderKeyStateStructure = senderKeyStateStructure;
+    }
+
+    getKeyId() {
+        return this.senderKeyStateStructure.senderKeyId;
+    }
+
+    getSenderChainKey() {
+        return new SenderChainKey(
+            this.senderKeyStateStructure.senderChainKey.iteration,
+            this.senderKeyStateStructure.senderChainKey.seed
+        );
+    }
+
+    setSenderChainKey(chainKey) {
+        const senderChainKeyStructure = protobufs.SenderChainKey.create({
+            iteration: chainKey.getIteration(),
+            seed: chainKey.getSeed(),
+        });
+        this.senderKeyStateStructure.senderChainKey = senderChainKeyStructure;
+    }
+
+    getSigningKeyPublic() {
+        return typeof this.senderKeyStateStructure.senderSigningKey.public === 'string' ?
+            Buffer.from(this.senderKeyStateStructure.senderSigningKey.public, 'base64') :
+            this.senderKeyStateStructure.senderSigningKey.public;
+    }
+
+    getSigningKeyPrivate() {
+        return typeof this.senderKeyStateStructure.senderSigningKey.private === 'string' ?
+            Buffer.from(this.senderKeyStateStructure.senderSigningKey.private, 'base64') :
+            this.senderKeyStateStructure.senderSigningKey.private;
+    }
+
+    hasSenderMessageKey(iteration) {
+        const list = this.senderKeyStateStructure.senderMessageKeys;
+        for (let o = 0; o < list.length; o++) {
+            const senderMessageKey = list[o];
+            if (senderMessageKey.iteration === iteration) return true;
+        }
+        return false;
+    }
+
+    addSenderMessageKey(senderMessageKey) {
+        const senderMessageKeyStructure = protobufs.SenderKeyStateStructure.create({
+            iteration: senderMessageKey.getIteration(),
+            seed: senderMessageKey.getSeed(),
+        });
+        this.senderKeyStateStructure.senderMessageKeys.push(senderMessageKeyStructure);
+
+        if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+            this.senderKeyStateStructure.senderMessageKeys.shift();
+        }
+    }
+
+    removeSenderMessageKey(iteration) {
+        let result = null;
+
+        this.senderKeyStateStructure.senderMessageKeys = this.senderKeyStateStructure.senderMessageKeys.filter(
+            senderMessageKey => {
+                if (senderMessageKey.iteration === iteration) result = senderMessageKey;
+                return senderMessageKey.iteration !== iteration;
+            }
+        );
+
+        if (result != null) {
+            return new SenderMessageKey(result.iteration, result.seed);
+        }
+        return null;
+    }
+
+    getStructure() {
+        return this.senderKeyStateStructure;
+    }
+}
+
+module.exports = SenderKeyState;

package/WASignalGroup/sender_message_key.js

@@ -0,0 +1,39 @@
+const { deriveSecrets } = require('libsignal/src/crypto');
+class SenderMessageKey {
+    iteration = 0;
+
+    iv = Buffer.alloc(0);
+
+    cipherKey = Buffer.alloc(0);
+
+    seed = Buffer.alloc(0);
+
+    constructor(iteration, seed) {
+        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
+        const keys = new Uint8Array(32);
+        keys.set(new Uint8Array(derivative[0].slice(16)));
+        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
+        this.iv = Buffer.from(derivative[0].slice(0, 16));
+        this.cipherKey = Buffer.from(keys.buffer);
+
+        this.iteration = iteration;
+        this.seed = seed;
+    }
+
+    getIteration() {
+        return this.iteration;
+    }
+
+    getIv() {
+        return this.iv;
+    }
+
+    getCipherKey() {
+        return this.cipherKey;
+    }
+
+    getSeed() {
+        return this.seed;
+    }
+}
+module.exports = SenderMessageKey;

package/lib/Defaults/baileys-version.json

@@ -0,0 +1,3 @@
+{
+    "version": [2, 3000, 1020608496]
+}

package/lib/Defaults/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CACHE_TTLS = exports.INITIAL_PREKEY_COUNT = exports.MIN_PREKEY_COUNT = exports.MEDIA_KEYS = exports.MEDIA_HKDF_KEY_MAPPING = exports.MEDIA_PATH_MAP = exports.DEFAULT_CONNECTION_CONFIG = exports.PROCESSABLE_HISTORY_TYPES = exports.WA_CERT_DETAILS = exports.URL_REGEX = exports.MOBILE_NOISE_HEADER = exports.PROTOCOL_VERSION = exports.NOISE_WA_HEADER = exports.KEY_BUNDLE_TYPE = exports.DICT_VERSION = exports.NOISE_MODE = exports.REGISTRATION_PUBLIC_KEY = exports.MOBILE_USERAGENT = exports.MOBILE_REGISTRATION_ENDPOINT = exports.MOBILE_TOKEN = exports.WA_DEFAULT_EPHEMERAL = exports.PHONE_CONNECTION_CB = exports.DEF_TAG_PREFIX = exports.DEF_CALLBACK_PREFIX = exports.MOBILE_PORT = exports.MOBILE_ENDPOINT = exports.DEFAULT_ORIGIN = exports.PHONENUMBER_MCC = exports.UNAUTHORIZED_CODES = void 0;
+const crypto_1 = require("crypto");
+const WAProto_1 = require("../../WAProto");
+const libsignal_1 = require("../Signal/libsignal");
+const Utils_1 = require("../Utils");
+const logger_1 = __importDefault(require("../Utils/logger"));
+const baileys_version_json_1 = require("./baileys-version.json");
+const phonenumber_mcc_json_1 = __importDefault(require("./phonenumber-mcc.json"));
+exports.UNAUTHORIZED_CODES = [401, 403, 419];
+exports.PHONENUMBER_MCC = phonenumber_mcc_json_1.default;
+exports.DEFAULT_ORIGIN = 'https://web.whatsapp.com';
+exports.MOBILE_ENDPOINT = 'g.whatsapp.net';
+exports.MOBILE_PORT = 443;
+exports.DEF_CALLBACK_PREFIX = 'CB:';
+exports.DEF_TAG_PREFIX = 'TAG:';
+exports.PHONE_CONNECTION_CB = 'CB:Pong';
+exports.WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+const WA_VERSION = '2.24.6.77';
+const WA_VERSION_HASH = (0, crypto_1.createHash)('md5').update(WA_VERSION).digest('hex');
+exports.MOBILE_TOKEN = Buffer.from('0a1mLfGUIBVrMKF1RdvLI5lkRBvof6vn0fD2QRSM' + WA_VERSION_HASH);
+exports.MOBILE_REGISTRATION_ENDPOINT = 'https://v.whatsapp.net/v2';
+exports.MOBILE_USERAGENT = `Telegram Android 11.7.0 Samsung Galaxy-A7-2017`;
+exports.REGISTRATION_PUBLIC_KEY = Buffer.from([
+    5, 142, 140, 15, 116, 195, 235, 197, 215, 166, 134, 92, 108, 60, 132, 56, 86, 176, 97, 33, 204, 232, 234, 119, 77,
+    34, 251, 111, 18, 37, 18, 48, 45,
+]);
+exports.NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
+exports.DICT_VERSION = 2;
+exports.KEY_BUNDLE_TYPE = Buffer.from([5]);
+exports.NOISE_WA_HEADER = Buffer.from([87, 65, 6, exports.DICT_VERSION]); // last is "DICT_VERSION"
+exports.PROTOCOL_VERSION = [5, 2];
+exports.MOBILE_NOISE_HEADER = Buffer.concat([Buffer.from('WA'), Buffer.from(exports.PROTOCOL_VERSION)]);
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+exports.URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
+exports.WA_CERT_DETAILS = {
+    SERIAL: 0,
+};
+exports.PROCESSABLE_HISTORY_TYPES = [
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.INITIAL_BOOTSTRAP,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.PUSH_NAME,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.RECENT,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.FULL,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.ON_DEMAND,
+];
+exports.DEFAULT_CONNECTION_CONFIG = {
+    version: baileys_version_json_1.version,
+    browser: Utils_1.Browsers.ubuntu('Chrome'),
+    waWebSocketUrl: 'https://web.whatsapp.com/ws/chat',
+    connectTimeoutMs: 20000,
+    keepAliveIntervalMs: 1000,
+    logger: logger_1.default.child({ class: 'baileys' }),
+    printQRInTerminal: false,
+    emitOwnEvents: true,
+    defaultQueryTimeoutMs: 60000,
+    customUploadHosts: [],
+    retryRequestDelayMs: 250,
+    maxMsgRetryCount: 5,
+    fireInitQueries: true,
+    auth: undefined,
+    markOnlineOnConnect: true,
+    syncFullHistory: false,
+    patchMessageBeforeSending: msg => msg,
+    shouldSyncHistoryMessage: () => true,
+    shouldIgnoreJid: () => false,
+    linkPreviewImageThumbnailWidth: 192,
+    transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
+    generateHighQualityLinkPreview: true,
+    options: {},
+    appStateMacVerification: {
+        patch: false,
+        snapshot: false,
+    },
+    countryCode: 'US',
+    getMessage: async () => undefined,
+    cachedGroupMetadata: async () => undefined,
+    makeSignalRepository: libsignal_1.makeLibSignalRepository
+};
+exports.MEDIA_PATH_MAP = {
+    image: '/mms/image',
+    video: '/mms/video',
+    document: '/mms/document',
+    audio: '/mms/audio',
+    sticker: '/mms/image',
+    'thumbnail-link': '/mms/image',
+    'product-catalog-image': '/product/image',
+    'md-app-state': '',
+    'md-msg-hist': '/mms/md-app-state',
+};
+exports.MEDIA_HKDF_KEY_MAPPING = {
+    'audio': 'Audio',
+    'document': 'Document',
+    'gif': 'Video',
+    'image': 'Image',
+    'ppic': '',
+    'product': 'Image',
+    'ptt': 'Audio',
+    'sticker': 'Image',
+    'video': 'Video',
+    'thumbnail-document': 'Document Thumbnail',
+    'thumbnail-image': 'Image Thumbnail',
+    'thumbnail-video': 'Video Thumbnail',
+    'thumbnail-link': 'Link Thumbnail',
+    'md-msg-hist': 'History',
+    'md-app-state': 'App State',
+    'product-catalog-image': '',
+    'payment-bg-image': 'Payment Background',
+    'ptv': 'Video'
+};
+exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP);
+exports.MIN_PREKEY_COUNT = 5;
+exports.INITIAL_PREKEY_COUNT = 30;
+exports.DEFAULT_CACHE_TTLS = {
+    SIGNAL_STORE: 5 * 60, // 5 minutes
+    MSG_RETRY: 60 * 60, // 1 hour
+    CALL_OFFER: 5 * 60, // 5 minutes
+    USER_DEVICES: 5 * 60, // 5 minutes
+};

package/lib/Defaults/phonenumber-mcc.json

@@ -0,0 +1,223 @@
+{
+    "93": 412,
+    "355": 276,
+    "213": 603,
+    "1-684": 544,
+    "376": 213,
+    "244": 631,
+    "1-264": 365,
+    "1-268": 344,
+    "54": 722,
+    "374": 283,
+    "297": 363,
+    "61": 505,
+    "43": 232,
+    "994": 400,
+    "1-242": 364,
+    "973": 426,
+    "880": 470,
+    "1-246": 342,
+    "375": 257,
+    "32": 206,
+    "501": 702,
+    "229": 616,
+    "1-441": 350,
+    "975": 402,
+    "591": 736,
+    "387": 218,
+    "267": 652,
+    "55": 724,
+    "1-284": 348,
+    "673": 528,
+    "359": 284,
+    "226": 613,
+    "257": 642,
+    "855": 456,
+    "237": 624,
+    "238": 625,
+    "1-345": 346,
+    "236": 623,
+    "235": 622,
+    "56": 730,
+    "86": 454,
+    "57": 732,
+    "269": 654,
+    "682": 548,
+    "506": 712,
+    "385": 219,
+    "53": 368,
+    "357": 280,
+    "420": 230,
+    "243": 630,
+    "45": 238,
+    "253": 638,
+    "1-767": 366,
+    "1-809": 370,
+    "1-849": 370,
+    "1-829": 370,
+    "593": 740,
+    "20": 602,
+    "503": 706,
+    "240": 627,
+    "291": 657,
+    "372": 248,
+    "251": 636,
+    "500": 750,
+    "298": 288,
+    "679": 542,
+    "358": 244,
+    "33": 208,
+    "689": 547,
+    "241": 628,
+    "220": 607,
+    "995": 282,
+    "49": 262,
+    "233": 620,
+    "350": 266,
+    "30": 202,
+    "299": 290,
+    "1-473": 352,
+    "1-671": 535,
+    "502": 704,
+    "224": 537,
+    "592": 738,
+    "509": 372,
+    "504": 708,
+    "852": 454,
+    "36": 216,
+    "354": 274,
+    "91": 404,
+    "62": 510,
+    "98": 432,
+    "964": 418,
+    "353": 234,
+    "972": 425,
+    "39": 222,
+    "225": 612,
+    "1-876": 338,
+    "81": 440,
+    "962": 416,
+    "254": 639,
+    "686": 545,
+    "383": 221,
+    "965": 419,
+    "371": 247,
+    "961": 415,
+    "266": 651,
+    "231": 618,
+    "218": 606,
+    "423": 295,
+    "370": 246,
+    "352": 270,
+    "389": 294,
+    "261": 646,
+    "265": 650,
+    "60": 502,
+    "960": 472,
+    "223": 610,
+    "356": 278,
+    "692": 551,
+    "222": 609,
+    "230": 617,
+    "52": 334,
+    "691": 550,
+    "373": 259,
+    "377": 212,
+    "976": 428,
+    "382": 297,
+    "1-664": 354,
+    "212": 604,
+    "258": 643,
+    "95": 414,
+    "264": 649,
+    "674": 536,
+    "977": 429,
+    "31": 204,
+    "687": 546,
+    "64": 530,
+    "505": 710,
+    "227": 614,
+    "234": 621,
+    "683": 555,
+    "1-670": 534,
+    "47": 242,
+    "968": 226,
+    "92": 410,
+    "680": 552,
+    "970": 423,
+    "507": 714,
+    "675": 537,
+    "595": 744,
+    "51": 716,
+    "63": 515,
+    "48": 260,
+    "351": 268,
+    "1-787, 1-939": 330,
+    "974": 427,
+    "242": 630,
+    "40": 226,
+    "7": 250,
+    "250": 635,
+    "290": 658,
+    "1-869": 356,
+    "1-758": 358,
+    "508": 308,
+    "1-784": 360,
+    "685": 544,
+    "378": 292,
+    "239": 626,
+    "966": 420,
+    "221": 608,
+    "381": 220,
+    "248": 633,
+    "232": 619,
+    "65": 525,
+    "386": 293,
+    "677": 540,
+    "27": 655,
+    "211": 659,
+    "34": 214,
+    "94": 413,
+    "249": 634,
+    "597": 746,
+    "268": 653,
+    "46": 240,
+    "41": 228,
+    "963": 417,
+    "886": 466,
+    "992": 436,
+    "255": 640,
+    "66": 520,
+    "228": 615,
+    "690": 554,
+    "676": 539,
+    "1-868": 374,
+    "216": 605,
+    "90": 286,
+    "993": 438,
+    "1-649": 376,
+    "688": 553,
+    "1-340": 332,
+    "256": 641,
+    "380": 255,
+    "971": 424,
+    "44": 234,
+    "1": 310,
+    "598": 748,
+    "998": 434,
+    "678": 541,
+    "379": 225,
+    "58": 734,
+    "681": 543,
+    "967": 421,
+    "260": 645,
+    "263": 648,
+    "670": 514,
+    "245": 632,
+    "856": 457,
+    "599": 362,
+    "850": 467,
+    "262": 647,
+    "82": 450,
+    "84": 452
+}

package/lib/Signal/libsignal.js

@@ -0,0 +1,161 @@
+"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 WASignalGroup_1 = require("../../WASignalGroup");
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth);
+    return {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid);
+            const cipher = new WASignalGroup_1.GroupCipher(storage, senderName);
+            return cipher.decrypt(msg);
+        },
+        async processSenderKeyDistributionMessage({ item, authorJid }) {
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
+            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+            }
+            await builder.process(senderName, senderMsg);
+        },
+        async decryptMessage({ jid, type, ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const session = new libsignal.SessionCipher(storage, addr);
+            let result;
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                    break;
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext);
+                    break;
+            }
+            return result;
+        },
+        async encryptMessage({ jid, data }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const cipher = new libsignal.SessionCipher(storage, addr);
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
+        },
+        async encryptGroupMessage({ group, meId, data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId);
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName);
+            const session = new WASignalGroup_1.GroupCipher(storage, senderName);
+            const ciphertext = await session.encrypt(data);
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+            };
+        },
+        async injectE2ESession({ jid, session }) {
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            await cipher.initOutgoing(session);
+        },
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString();
+        },
+    };
+}
+const jidToSignalProtocolAddress = (jid) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
+    return new libsignal.ProtocolAddress(user, device || 0);
+};
+const jidToSignalSenderKeyName = (group, user) => {
+    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString();
+};
+function signalStorage({ creds, keys }) {
+    return {
+        loadSession: async (id) => {
+            const { [id]: sess } = await keys.get('session', [id]);
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess);
+            }
+        },
+        storeSession: async (id, session) => {
+            await keys.set({ 'session': { [id]: session.serialize() } });
+        },
+        isTrustedIdentity: () => {
+            return true;
+        },
+        loadPreKey: async (id) => {
+            const keyId = id.toString();
+            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                };
+            }
+        },
+        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)
+            };
+        },
+        loadSenderKey: async (keyId) => {
+            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            if (key) {
+                return new WASignalGroup_1.SenderKeyRecord(key);
+            }
+        },
+        storeSenderKey: async (keyId, key) => {
+            await keys.set({ 'sender-key': { [keyId]: key.serialize() } });
+        },
+        getOurRegistrationId: () => (creds.registrationId),
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds;
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public),
+            };
+        }
+    };
+}

package/lib/Socket/Client/abstract-socket-client.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient;