gifted-baileys 1.5.4 → 1.5.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gifted-baileys",
-  "version": "1.5.4",
-  "description": "Typescript/Javascript WhatsApp Web API",
+  "version": "1.5.5",
+  "description": "Typescript/Javascript WhatsApp Web API", 
   "keywords": [
     "whatsapp",
     "js-whatsapp",
@@ -19,41 +19,23 @@
     "url": "https://baileys.giftedtech.web.id"
   },
   "license": "MIT",
-  "author": "Gifted Tech",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "author": "GiftedTech",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
   "files": [
-    "lib/*",
+    "src/*",
     "WAProto/*",
     "WASignalGroup/*.js"
   ],
-  "scripts": {
-    "build:all": "tsc && typedoc",
-    "build:docs": "typedoc",
-    "build:tsc": "tsc",
-    "changelog:last": "conventional-changelog -p angular -r 2",
-    "changelog:preview": "conventional-changelog -p angular -u",
-    "changelog:update": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
-    "example": "node --inspect -r ts-node/register Example/example.ts",
-    "example:mobile": "node --inspect -r ts-node/register Example/example.ts --mobile",
-    "gen:protobuf": "sh WAProto/GenerateStatics.sh",
-    "lint": "eslint src --ext .js,.ts,.jsx,.tsx",
-    "lint:fix": "eslint src --fix --ext .js,.ts,.jsx,.tsx",
-    "prepack": "tsc",
-    "prepare": "tsc",
-    "release": "release-it",
-    "test": "jest"
-  },
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@hapi/boom": "^9.1.3",
-    "async-lock": "^1.4.1",
     "audio-decode": "^2.1.3",
     "axios": "^1.3.3",
     "cache-manager": "4.0.1",
     "futoin-hkdf": "^1.5.1",
     "libphonenumber-js": "^1.10.20",
-    "libsignal": "github:WhiskeySockets/libsignal-node",
+    "libsignal": "github:adiwajshing/libsignal-node",
     "music-metadata": "^7.12.3",
     "node-cache": "^5.1.2",
     "pino": "^7.0.0",
@@ -62,7 +44,7 @@
     "ws": "^8.13.0"
   },
   "devDependencies": {
-    "@adiwajshing/eslint-config": "github:whiskeysockets/eslint-config",
+    "@adiwajshing/eslint-config": "github:adiwajshing/eslint-config",
     "@types/got": "^9.6.11",
     "@types/jest": "^27.5.1",
     "@types/node": "^16.0.0",
@@ -71,7 +53,7 @@
     "conventional-changelog-cli": "^2.2.2",
     "eslint": "^8.0.0",
     "jest": "^27.0.6",
-    "jimp": "^0.16.1",
+    "jimp": "^0.22.12",
     "link-preview-js": "^3.0.0",
     "open": "^8.4.2",
     "qrcode-terminal": "^0.12.0",

package/src/Defaults/baileys-version.json

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

package/{lib → src}/Defaults/index.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -44,8 +53,7 @@ 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,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.FULL
 ];
 exports.DEFAULT_CONNECTION_CONFIG = {
     version: baileys_version_json_1.version,
@@ -75,8 +83,7 @@ exports.DEFAULT_CONNECTION_CONFIG = {
         patch: false,
         snapshot: false,
     },
-    getMessage: async () => undefined,
-    cachedGroupMetadata: async () => undefined,
+    getMessage: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
     makeSignalRepository: libsignal_1.makeLibSignalRepository
 };
 exports.MEDIA_PATH_MAP = {
@@ -114,8 +121,8 @@ 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,
-    MSG_RETRY: 60 * 60,
-    CALL_OFFER: 5 * 60,
+    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/src/Defaults/index.ts

@@ -0,0 +1,131 @@
+import { createHash } from 'crypto'
+import { proto } from '../../WAProto'
+import { makeLibSignalRepository } from '../Signal/libsignal'
+import type { AuthenticationState, MediaType, SocketConfig, WAVersion } from '../Types'
+import { Browsers } from '../Utils'
+import logger from '../Utils/logger'
+import { version } from './baileys-version.json'
+import phoneNumberMCC from './phonenumber-mcc.json'
+
+export const UNAUTHORIZED_CODES = [401, 403, 419]
+
+export const PHONENUMBER_MCC = phoneNumberMCC
+
+export const DEFAULT_ORIGIN = 'https://web.whatsapp.com'
+export const MOBILE_ENDPOINT = 'g.whatsapp.net'
+export const MOBILE_PORT = 443
+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
+
+const WA_VERSION = '2.24.6.77'
+
+const WA_VERSION_HASH = createHash('md5').update(WA_VERSION).digest('hex')
+export const MOBILE_TOKEN = Buffer.from('0a1mLfGUIBVrMKF1RdvLI5lkRBvof6vn0fD2QRSM' + WA_VERSION_HASH)
+export const MOBILE_REGISTRATION_ENDPOINT = 'https://v.whatsapp.net/v2'
+export const MOBILE_USERAGENT = `WhatsApp/${WA_VERSION} iOS/15.3.1 Device/Apple-iPhone_7`
+export const 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,
+])
+export const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0'
+export const DICT_VERSION = 2
+export const KEY_BUNDLE_TYPE = Buffer.from([5])
+export const NOISE_WA_HEADER = Buffer.from(
+	[ 87, 65, 6, DICT_VERSION ]
+) // last is "DICT_VERSION"
+export const PROTOCOL_VERSION = [5, 2]
+export const MOBILE_NOISE_HEADER = Buffer.concat([Buffer.from('WA'), Buffer.from(PROTOCOL_VERSION)])
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export const URL_REGEX = /(http(s)?:\/\/.)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/
+
+export const 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
+]
+
+export const DEFAULT_CONNECTION_CONFIG: SocketConfig = {
+	version: version as WAVersion,
+	browser: Browsers.ubuntu('Chrome'),
+	waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
+	connectTimeoutMs: 20_000,
+	keepAliveIntervalMs: 30_000,
+	logger: logger.child({ class: 'baileys' }),
+	printQRInTerminal: false,
+	emitOwnEvents: true,
+	defaultQueryTimeoutMs: 60_000,
+	customUploadHosts: [],
+	retryRequestDelayMs: 250,
+	maxMsgRetryCount: 5,
+	fireInitQueries: true,
+	auth: undefined as unknown as AuthenticationState,
+	markOnlineOnConnect: true,
+	syncFullHistory: false,
+	patchMessageBeforeSending: msg => msg,
+	shouldSyncHistoryMessage: () => true,
+	shouldIgnoreJid: () => false,
+	linkPreviewImageThumbnailWidth: 192,
+	transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
+	generateHighQualityLinkPreview: false,
+	options: { },
+	appStateMacVerification: {
+		patch: false,
+		snapshot: false,
+	},
+	getMessage: async() => undefined,
+	makeSignalRepository: makeLibSignalRepository
+}
+
+export const MEDIA_PATH_MAP: { [T in MediaType]?: string } = {
+	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',
+}
+
+export const 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'
+}
+
+export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP) as MediaType[]
+
+export const MIN_PREKEY_COUNT = 5
+
+export const INITIAL_PREKEY_COUNT = 30
+
+export const 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/src/Signal/libsignal.js

@@ -0,0 +1,180 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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);
+        },
+        processSenderKeyDistributionMessage(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ 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 } = yield auth.keys.get('sender-key', [senderName]);
+                if (!senderKey) {
+                    yield storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+                }
+                yield builder.process(senderName, senderMsg);
+            });
+        },
+        decryptMessage(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ jid, type, ciphertext }) {
+                const addr = jidToSignalProtocolAddress(jid);
+                const session = new libsignal.SessionCipher(storage, addr);
+                let result;
+                switch (type) {
+                    case 'pkmsg':
+                        result = yield session.decryptPreKeyWhisperMessage(ciphertext);
+                        break;
+                    case 'msg':
+                        result = yield session.decryptWhisperMessage(ciphertext);
+                        break;
+                }
+                return result;
+            });
+        },
+        encryptMessage(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ jid, data }) {
+                const addr = jidToSignalProtocolAddress(jid);
+                const cipher = new libsignal.SessionCipher(storage, addr);
+                const { type: sigType, body } = yield cipher.encrypt(data);
+                const type = sigType === 3 ? 'pkmsg' : 'msg';
+                return { type, ciphertext: Buffer.from(body, 'binary') };
+            });
+        },
+        encryptGroupMessage(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ group, meId, data }) {
+                const senderName = jidToSignalSenderKeyName(group, meId);
+                const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+                const { [senderName]: senderKey } = yield auth.keys.get('sender-key', [senderName]);
+                if (!senderKey) {
+                    yield storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+                }
+                const senderKeyDistributionMessage = yield builder.create(senderName);
+                const session = new WASignalGroup_1.GroupCipher(storage, senderName);
+                const ciphertext = yield session.encrypt(data);
+                return {
+                    ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+                };
+            });
+        },
+        injectE2ESession(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ jid, session }) {
+                const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+                yield 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: (id) => __awaiter(this, void 0, void 0, function* () {
+            const { [id]: sess } = yield keys.get('session', [id]);
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess);
+            }
+        }),
+        storeSession: (id, session) => __awaiter(this, void 0, void 0, function* () {
+            yield keys.set({ 'session': { [id]: session.serialize() } });
+        }),
+        isTrustedIdentity: () => {
+            return true;
+        },
+        loadPreKey: (id) => __awaiter(this, void 0, void 0, function* () {
+            const keyId = id.toString();
+            const { [keyId]: key } = yield 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: (keyId) => __awaiter(this, void 0, void 0, function* () {
+            const { [keyId]: key } = yield keys.get('sender-key', [keyId]);
+            if (key) {
+                return new WASignalGroup_1.SenderKeyRecord(key);
+            }
+        }),
+        storeSenderKey: (keyId, key) => __awaiter(this, void 0, void 0, function* () {
+            yield 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/src/Signal/libsignal.ts

@@ -0,0 +1,141 @@
+import * as libsignal from 'libsignal'
+import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage, SenderKeyName, SenderKeyRecord } from '../../WASignalGroup'
+import { SignalAuthState } from '../Types'
+import { SignalRepository } from '../Types/Signal'
+import { generateSignalPubKey } from '../Utils'
+import { jidDecode } from '../WABinary'
+
+export function makeLibSignalRepository(auth: SignalAuthState): SignalRepository {
+	const storage = signalStorage(auth)
+	return {
+		decryptGroupMessage({ group, authorJid, msg }) {
+			const senderName = jidToSignalSenderKeyName(group, authorJid)
+			const cipher = new GroupCipher(storage, senderName)
+
+			return cipher.decrypt(msg)
+		},
+		async processSenderKeyDistributionMessage({ item, authorJid }) {
+			const builder = new GroupSessionBuilder(storage)
+			const senderName = jidToSignalSenderKeyName(item.groupId!, authorJid)
+
+			const senderMsg = new 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 builder.process(senderName, senderMsg)
+		},
+		async decryptMessage({ jid, type, ciphertext }) {
+			const addr = jidToSignalProtocolAddress(jid)
+			const session = new libsignal.SessionCipher(storage, addr)
+			let result: Buffer
+			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 GroupSessionBuilder(storage)
+
+			const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
+			if(!senderKey) {
+				await storage.storeSenderKey(senderName, new SenderKeyRecord())
+			}
+
+			const senderKeyDistributionMessage = await builder.create(senderName)
+			const session = new 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: string) => {
+	const { user, device } = jidDecode(jid)!
+	return new libsignal.ProtocolAddress(user, device || 0)
+}
+
+const jidToSignalSenderKeyName = (group: string, user: string): string => {
+	return new SenderKeyName(group, jidToSignalProtocolAddress(user)).toString()
+}
+
+function signalStorage({ creds, keys }: SignalAuthState) {
+	return {
+		loadSession: async(id: string) => {
+			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: number | string) => {
+			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: number) => 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: string) => {
+			const { [keyId]: key } = await keys.get('sender-key', [keyId])
+			if(key) {
+				return new 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: generateSignalPubKey(signedIdentityKey.public),
+			}
+		}
+	}
+}

package/src/Socket/Client/abstract-socket-client.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from 'events'
+import { URL } from 'url'
+import { SocketConfig } from '../../Types'
+
+export abstract class AbstractSocketClient extends EventEmitter {
+	abstract get isOpen(): boolean
+	abstract get isClosed(): boolean
+	abstract get isClosing(): boolean
+	abstract get isConnecting(): boolean
+
+	constructor(public url: URL, public config: SocketConfig) {
+		super()
+		this.setMaxListeners(0)
+	}
+
+	abstract connect(): Promise<void>
+	abstract close(): Promise<void>
+	abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+}

package/{lib → src}/Socket/Client/index.js

@@ -14,5 +14,6 @@ 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("./types"), exports);
-__exportStar(require("./websocket"), exports);
+__exportStar(require("./abstract-socket-client"), exports);
+__exportStar(require("./mobile-socket-client"), exports);
+__exportStar(require("./web-socket-client"), exports);

package/src/Socket/Client/index.ts

@@ -0,0 +1,3 @@
+export * from './abstract-socket-client'
+export * from './mobile-socket-client'
+export * from './web-socket-client'