@baileys-md/baileys 11.0.3 → 11.1.0

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/{lib/Signal/Group/sender-message-key.js → WASignalGroup/sender_message_key.js}

@@ -1,6 +1,13 @@
-/* @ts-ignore */
-import { deriveSecrets } from 'libsignal/src/crypto.js';
-export class SenderMessageKey {
+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);
@@ -8,20 +15,25 @@ export class SenderMessageKey {
         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;
     }
 }
-//# sourceMappingURL=sender-message-key.js.map
+module.exports = SenderMessageKey;

package/lib/Defaults/baileys-version.json

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

package/lib/Defaults/index.js

@@ -1,40 +1,60 @@
-import { proto } from '../../WAProto/index.js';
-import { makeLibSignalRepository } from '../Signal/libsignal.js';
-import { Browsers } from '../Utils/index.js';
-import logger from '../Utils/logger.js';
-import * as defaultVersion from '../Defaults/baileys-version.js'
-import number from './phonenumber-mcc.js'
-const { version } = defaultVersion;
-export const PHONENUMBER_MCC = number;
-export const UNAUTHORIZED_CODES = [401, 403, 419];
-export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
-export const DEF_CALLBACK_PREFIX = 'CB:';
-export const DEF_TAG_PREFIX = 'TAG:';
-export const PHONE_CONNECTION_CB = 'CB:Pong';
-export const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
-export const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
-export const DICT_VERSION = 3;
-export const KEY_BUNDLE_TYPE = Buffer.from([5]);
-export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]); // last is "DICT_VERSION"
+"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 */
-export const URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
-export const WA_CERT_DETAILS = {
-    SERIAL: 0
+exports.URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
+exports.WA_CERT_DETAILS = {
+    SERIAL: 0,
 };
-export const PROCESSABLE_HISTORY_TYPES = [
-    proto.Message.HistorySyncNotification.HistorySyncType.INITIAL_BOOTSTRAP,
-    proto.Message.HistorySyncNotification.HistorySyncType.PUSH_NAME,
-    proto.Message.HistorySyncNotification.HistorySyncType.RECENT,
-    proto.Message.HistorySyncNotification.HistorySyncType.FULL,
-    proto.Message.HistorySyncNotification.HistorySyncType.ON_DEMAND
+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,
 ];
-export const DEFAULT_CONNECTION_CONFIG = {
-    version: version,
-    browser: Browsers.ubuntu('Chrome'),
+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.child({ class: 'baileys' }),
+    logger: logger_1.default.child({ class: 'baileys' }),
+    printQRInTerminal: false,
     emitOwnEvents: true,
     defaultQueryTimeoutMs: 60000,
     customUploadHosts: [],
@@ -53,14 +73,14 @@ export const DEFAULT_CONNECTION_CONFIG = {
     options: {},
     appStateMacVerification: {
         patch: false,
-        snapshot: false
+        snapshot: false,
     },
     countryCode: 'US',
     getMessage: async () => undefined,
     cachedGroupMetadata: async () => undefined,
-    makeSignalRepository: makeLibSignalRepository
+    makeSignalRepository: libsignal_1.makeLibSignalRepository
 };
-export const MEDIA_PATH_MAP = {
+exports.MEDIA_PATH_MAP = {
     image: '/mms/image',
     video: '/mms/video',
     document: '/mms/document',
@@ -69,18 +89,18 @@ export const MEDIA_PATH_MAP = {
     'thumbnail-link': '/mms/image',
     'product-catalog-image': '/product/image',
     'md-app-state': '',
-    'md-msg-hist': '/mms/md-app-state'
+    'md-msg-hist': '/mms/md-app-state',
 };
-export const MEDIA_HKDF_KEY_MAPPING = {
-    audio: 'Audio',
-    document: 'Document',
-    gif: 'Video',
-    image: 'Image',
-    ppic: '',
-    product: 'Image',
-    ptt: 'Audio',
-    sticker: 'Image',
-    video: 'Video',
+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',
@@ -89,15 +109,14 @@ export const MEDIA_HKDF_KEY_MAPPING = {
     'md-app-state': 'App State',
     'product-catalog-image': '',
     'payment-bg-image': 'Payment Background',
-    ptv: 'Video'
+    'ptv': 'Video'
 };
-export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
-export const MIN_PREKEY_COUNT = 5;
-export const INITIAL_PREKEY_COUNT = 30;
-export const DEFAULT_CACHE_TTLS = {
+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
+    USER_DEVICES: 5 * 60, // 5 minutes
 };
-//# sourceMappingURL=index.js.map

package/lib/Defaults/{phonenumber-mcc.js → phonenumber-mcc.json}

@@ -1,4 +1,4 @@
-export default {
+{
     "93": 412,
     "355": 276,
     "213": 603,

package/lib/Signal/libsignal.js

@@ -1,29 +1,58 @@
-/* @ts-ignore */
-import * as libsignal from 'libsignal';
-import { generateSignalPubKey } from '../Utils/index.js';
-import { jidDecode } from '../WABinary/index.js';
-import { SenderKeyName } from './Group/sender-key-name.js';
-import { SenderKeyRecord } from './Group/sender-key-record.js';
-import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage } from './Group/index.js';
-export function makeLibSignalRepository(auth) {
+"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 GroupCipher(storage, senderName);
+            const cipher = new WASignalGroup_1.GroupCipher(storage, senderName);
             return cipher.decrypt(msg);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new GroupSessionBuilder(storage);
-            if (!item.groupId) {
-                throw new Error('Group ID is required for sender key distribution message');
-            }
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
-            const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
-            const senderNameStr = senderName.toString();
-            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            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 SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
             }
             await builder.process(senderName, senderMsg);
         },
@@ -38,8 +67,6 @@ export function makeLibSignalRepository(auth) {
                 case 'msg':
                     result = await session.decryptWhisperMessage(ciphertext);
                     break;
-                default:
-                    throw new Error(`Unknown message type: ${type}`);
             }
             return result;
         },
@@ -52,18 +79,17 @@ export function makeLibSignalRepository(auth) {
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
-            const builder = new GroupSessionBuilder(storage);
-            const senderNameStr = senderName.toString();
-            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
             }
             const senderKeyDistributionMessage = await builder.create(senderName);
-            const session = new GroupCipher(storage, senderName);
+            const session = new WASignalGroup_1.GroupCipher(storage, senderName);
             const ciphertext = await session.encrypt(data);
             return {
                 ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
             };
         },
         async injectE2ESession({ jid, session }) {
@@ -72,15 +98,15 @@ export function makeLibSignalRepository(auth) {
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
-        }
+        },
     };
 }
 const jidToSignalProtocolAddress = (jid) => {
-    const { user, device } = jidDecode(jid);
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
     return new libsignal.ProtocolAddress(user, device || 0);
 };
 const jidToSignalSenderKeyName = (group, user) => {
-    return new SenderKeyName(group, jidToSignalProtocolAddress(user));
+    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString();
 };
 function signalStorage({ creds, keys }) {
     return {
@@ -90,9 +116,8 @@ function signalStorage({ creds, keys }) {
                 return libsignal.SessionRecord.deserialize(sess);
             }
         },
-        // TODO: Replace with libsignal.SessionRecord when type exports are added to libsignal
         storeSession: async (id, session) => {
-            await keys.set({ session: { [id]: session.serialize() } });
+            await keys.set({ 'session': { [id]: session.serialize() } });
         },
         isTrustedIdentity: () => {
             return true;
@@ -115,27 +140,22 @@ function signalStorage({ creds, keys }) {
                 pubKey: Buffer.from(key.keyPair.public)
             };
         },
-        loadSenderKey: async (senderKeyName) => {
-            const keyId = senderKeyName.toString();
+        loadSenderKey: async (keyId) => {
             const { [keyId]: key } = await keys.get('sender-key', [keyId]);
             if (key) {
-                return SenderKeyRecord.deserialize(key);
+                return new WASignalGroup_1.SenderKeyRecord(key);
             }
-            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') } });
+        storeSenderKey: async (keyId, key) => {
+            await keys.set({ 'sender-key': { [keyId]: key.serialize() } });
         },
-        getOurRegistrationId: () => creds.registrationId,
+        getOurRegistrationId: () => (creds.registrationId),
         getOurIdentity: () => {
             const { signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: generateSignalPubKey(signedIdentityKey.public)
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public),
             };
         }
     };
 }
-//# sourceMappingURL=libsignal.js.map

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;

package/lib/Socket/Client/index.js

@@ -1,3 +1,19 @@
-export * from './types.js';
-export * from './websocket.js';
-//# sourceMappingURL=index.js.map
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-socket-client"), exports);
+__exportStar(require("./mobile-socket-client"), exports);
+__exportStar(require("./web-socket-client"), exports);

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileSocketClient = void 0;
+const net_1 = require("net");
+const abstract_socket_client_1 = require("./abstract-socket-client");
+class MobileSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'open';
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'opening';
+    }
+    async connect() {
+        var _a;
+        if (this.socket) {
+            return;
+        }
+        if (this.config.agent) {
+            throw new Error('There are not support for proxy agent for mobile connection');
+        }
+        else {
+            this.socket = (0, net_1.connect)({
+                host: this.url.hostname,
+                port: Number(this.url.port) || 443
+            });
+        }
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'connect', 'data', 'drain', 'end', 'error', 'lookup', 'ready', 'timeout'];
+        for (const event of events) {
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(event, (...args) => this.emit(event, ...args));
+        }
+        this.socket.on('data', (...args) => this.emit('message', ...args));
+        this.socket.on('ready', (...args) => this.emit('open', ...args));
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        return new Promise(resolve => {
+            this.socket.end(resolve);
+            this.socket = null;
+        });
+    }
+    send(str, cb) {
+        if (this.socket === null) {
+            return false;
+        }
+        return this.socket.write(str, undefined, cb);
+    }
+}
+exports.MobileSocketClient = MobileSocketClient;