@skyzopedia/baileys-mod 3.0.2

package/lib/Defaults/index.js

@@ -0,0 +1,123 @@
+//=======================================================//
+import { makeLibSignalRepository } from "../Signal/libsignal.js";
+import { Browsers } from "../Utils/browser-utils.js";
+import { proto } from "../../WAProto/index.js";
+import logger from "../Utils/logger.js";
+//=======================================================//
+export const version = [2, 3000, 1028716292];
+export const DICT_VERSION = 3;
+//=======================================================//
+export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]);
+export const CALL_VIDEO_PREFIX = "https://call.whatsapp.com/video/";
+export const CALL_AUDIO_PREFIX = "https://call.whatsapp.com/voice/";
+export const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+export const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
+export const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+export const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+export const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+export const DEFAULT_ORIGIN = "https://web.whatsapp.com";
+export const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+export const UNAUTHORIZED_CODES = [401, 403, 419];
+export const KEY_BUNDLE_TYPE = Buffer.from([5]);
+export const PHONE_CONNECTION_CB = "CB:Pong";
+export const DEF_CALLBACK_PREFIX = "CB:";
+export const DEF_TAG_PREFIX = "TAG:";
+//=======================================================//
+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
+};
+//=======================================================//
+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,
+  proto.Message.HistorySyncNotification.HistorySyncType.NON_BLOCKING_DATA,
+  proto.Message.HistorySyncNotification.HistorySyncType.INITIAL_STATUS_V3
+];
+//=======================================================//
+export const DEFAULT_CONNECTION_CONFIG = {
+  "version": version,
+  "browser": Browsers.iOS("Safari"),
+  "waWebSocketUrl": "wss://web.whatsapp.com/ws/chat",
+  "connectTimeoutMs": 20000,
+  "keepAliveIntervalMs": 30000,
+  "logger": logger.child({ "class": "baileys" }),
+  "emitOwnEvents": true,
+  "defaultQueryTimeoutMs": 60000,
+  "customUploadHosts": [],
+  "retryRequestDelayMs": 250,
+  "maxMsgRetryCount": 5,
+  "fireInitQueries": true,
+  "auth": undefined,
+  "markOnlineOnConnect": true,
+  "syncFullHistory": true,
+  "patchMessageBeforeSending": msg => msg,
+  "shouldSyncHistoryMessage": () => true,
+  "shouldIgnoreJid": () => false,
+  "linkPreviewImageThumbnailWidth": 192,
+  "transactionOpts": { "maxCommitRetries": 10, "delayBetweenTriesMs": 3000 },
+  "generateHighQualityLinkPreview": false,
+  "enableAutoSessionRecreation": true,
+  "enableRecentMessageCache": true,
+  "options": {},
+  "appStateMacVerification": {
+    "patch": false,
+    "snapshot": false
+  },
+  "countryCode": "US",
+  "getMessage": async () => undefined,
+  "cachedGroupMetadata": async () => undefined,
+  "makeSignalRepository": makeLibSignalRepository
+};
+//=======================================================//
+export const 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",
+  "biz-cover-photo": "/pps/biz-cover-photo"
+};
+//=======================================================//
+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",
+  "biz-cover-photo": "Image"
+};
+//=======================================================//
+export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+export const MIN_PREKEY_COUNT = 5;
+export const INITIAL_PREKEY_COUNT = 812;
+export const UPLOAD_TIMEOUT = 30000;
+export const MIN_UPLOAD_INTERVAL = 5000;
+export const DEFAULT_CACHE_TTLS = {
+  SIGNAL_STORE: 5 * 60,
+  MSG_RETRY: 60 * 60,
+  CALL_OFFER: 5 * 60,
+  USER_DEVICES: 5 * 60
+};
+//=======================================================//

package/lib/KeyDB/BinarySearch.js

@@ -0,0 +1,20 @@
+//===================================//
+export default function binarySearch(array, predicate) {
+  let low = 0;
+  let high = array.length;
+  if (array.length === 0) return low;
+  if (predicate(array[low]) < 0) return low - 1;
+  else if (predicate(array[low]) === 0) return low;
+  const maxPred = predicate(array[high - 1]);
+  if (maxPred > 0) return high;
+  else if (maxPred === 0) return high - 1;
+  while (low !== high) {
+    const mid = low + Math.floor((high - low) / 2);
+    const pred = predicate(array[mid]);
+    if (pred < 0) high = mid;
+    else if (pred > 0) low = mid + 1;
+    else return mid;
+  }
+  return low;
+}
+//===================================//

package/lib/KeyDB/KeyedDB.js

@@ -0,0 +1,167 @@
+//===================================//
+import binarySearch from "./BinarySearch.js";
+//===================================//
+export default class KeyedDB {
+  constructor(key, id) {
+    this.key = key;
+    this.idGetter = id || (v => this.key.key(v).toString());
+    this.dict = {};
+    this.array = [];
+  }
+  get length() {
+    return this.array.length;
+  }
+  get first() {
+    return this.array[0];
+  }
+  get last() {
+    return this.array[this.array.length - 1];
+  }
+  toJSON() {
+    return this.array;
+  }
+  insert(...values) {
+    values.forEach(v => this._insertSingle(v));
+  }
+  upsert(...values) {
+    const updates = [];
+    values.forEach(v => {
+      if (!v) return;
+      const deleted = this.deleteById(this.idGetter(v), false);
+      this._insertSingle(v);
+      deleted && updates.push(v);
+    });
+    return updates;
+  }
+  insertIfAbsent(...values) {
+    const insertions = [];
+    values.forEach(v => {
+      if (!v) return;
+      const presentValue = this.get(this.idGetter(v));
+      if (presentValue) return;
+      const presentKey = this.firstIndex(v);
+      if (this.array[presentKey] && this.key.key(this.array[presentKey]) === this.key.key(v)) return;
+      this.insert(v);
+      insertions.push(v);
+    });
+    return insertions;
+  }
+  deleteById(id, assertPresent = true) {
+    const value = this.get(id);
+    if (!value) {
+      if (assertPresent) throw new Error(`Value not found`);
+      return;
+    }
+    return this.delete(value);
+  }
+  delete(value) {
+    const index = this.firstIndex(value);
+    if (index < 0 || index >= this.array.length || this.key.key(value) !== this.key.key(this.array[index])) {
+      return null;
+    }
+    delete this.dict[this.idGetter(value)];
+    return this.array.splice(index, 1)[0];
+  }
+  slice(start, end) {
+    const db = new KeyedDB(this.key, this.idGetter);
+    db.array = this.array.slice(start, end);
+    db.array.forEach(item => db.dict[this.idGetter(item)] = item);
+    return db;
+  }
+  clear() {
+    this.array = [];
+    this.dict = {};
+  }
+  get(id) {
+    return this.dict[id];
+  }
+  all() {
+    return this.array;
+  }
+  update(id, update) {
+    const value = this.get(id);
+    if (value) {
+      const idx = this.firstIndex(value);
+      if (idx >= 0 && idx < this.array.length && this.idGetter(this.array[idx]) === id) {
+        const oldKey = this.key.key(value);
+        update(value);
+        const newKey = this.key.key(value);
+        if (newKey !== oldKey) {
+          delete this.dict[id];
+          this.array.splice(idx, 1);
+          this._insertSingle(value);
+          return 2;
+        }
+        return 1;
+      }
+    }
+  }
+  updateKey(value, update) {
+    return this.update(this.idGetter(value), update);
+  }
+  filter(predicate) {
+    const db = new KeyedDB(this.key, this.idGetter);
+    db.array = this.array.filter((value, index) => {
+      if (predicate(value, index)) {
+        db.dict[this.idGetter(value)] = value;
+        return true;
+      }
+    });
+    return db;
+  }
+  paginatedByValue(value, limit, predicate, mode = "after") {
+    return this.paginated(value && this.key.key(value), limit, predicate, mode);
+  }
+  paginated(cursor, limit, predicate, mode = "after") {
+    let index = mode === "after" ? 0 : this.array.length;
+    if (cursor !== null && typeof cursor !== "undefined") {
+      index = binarySearch(this.array, v => this.key.compare(cursor, this.key.key(v)));
+      if (index < 0) index = 0;
+      if (this.key.key(this.array[index]) === cursor) index += (mode === "after" ? 1 : 0);
+    }
+    return this.filtered(index, limit, mode, predicate);
+  }
+  _insertSingle(value) {
+    if (!value) throw new Error("falsey value");
+    const valueID = this.idGetter(value);
+    if (this.get(valueID)) throw new Error("duplicate ID being inserted: " + valueID);
+
+    if (this.array.length > 0) {
+      const index = this.firstIndex(value);
+      if (index >= this.array.length) this.array.push(value);
+      else if (index < 0) this.array.unshift(value);
+      else if (this.key.key(value) !== this.key.key(this.array[index])) this.array.splice(index, 0, value);
+      else throw new Error(`duplicate key: ${this.key.key(value)}, inserting: ${valueID}, present: ${this.idGetter(this.array[index])}`);
+    } else {
+      this.array.push(value);
+    }
+    this.dict[valueID] = value;
+  }
+  filtered(start, count, mode, predicate) {
+    let arr;
+    if (mode === "after") {
+      if (predicate) {
+        arr = [];
+        for (let item of this.array.slice(start)) {
+          predicate(item, start + arr.length) && arr.push(item);
+          if (arr.length >= count) break;
+        }
+      } else arr = this.array.slice(start, start + count);
+    } else if (mode === "before") {
+      if (predicate) {
+        arr = [];
+        for (let i = start - 1; i >= 0; i--) {
+          let item = this.array[i];
+          predicate(item, start + arr.length) && arr.unshift(item);
+          if (arr.length >= count) break;
+        }
+      } else arr = this.array.slice(Math.max(start - count, 0), start);
+    }
+    return arr;
+  }
+  firstIndex(value) {
+    const valueKey = this.key.key(value);
+    return binarySearch(this.array, v => this.key.compare(valueKey, this.key.key(v)));
+  }
+}
+//===================================//

package/lib/KeyDB/index.js

@@ -0,0 +1,4 @@
+//===================================//
+export * from "./BinarySearch.js"
+export * from "./KeyedDB.js"
+//===================================//

package/lib/Signal/Group/ciphertext-message.js

@@ -0,0 +1,13 @@
+//=======================================================//
+export class CiphertextMessage {
+  constructor() {
+    this.UNSUPPORTED_VERSION = 1;
+    this.CURRENT_VERSION = 3;
+    this.WHISPER_TYPE = 2;
+    this.PREKEY_TYPE = 3;
+    this.SENDERKEY_TYPE = 4;
+    this.SENDERKEY_DISTRIBUTION_TYPE = 5;
+    this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
+  }
+}
+//=======================================================//

package/lib/Signal/Group/group-session-builder.js

@@ -0,0 +1,32 @@
+//=======================================================//
+import { SenderKeyDistributionMessage } from "./sender-key-distribution-message.js";
+import { SenderKeyRecord } from "./sender-key-record.js";
+import { SenderKeyName } from "./sender-key-name.js";
+import * as keyhelper from "./keyhelper.js";
+//=======================================================//
+export class GroupSessionBuilder {
+    constructor(senderKeyStore) {
+        this.senderKeyStore = senderKeyStore;
+    }
+    async process(senderKeyName, senderKeyDistributionMessage) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey());
+        await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+    async create(senderKeyName) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        if (senderKeyRecord.isEmpty()) {
+            const keyId = keyhelper.generateSenderKeyId();
+            const senderKey = keyhelper.generateSenderKey();
+            const signingKey = keyhelper.generateSenderSigningKey();
+            senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+            await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+        }
+        const state = senderKeyRecord.getSenderKeyState();
+        if (!state) {
+            throw new Error("No session state available");
+        }
+        return new SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
+    }
+}
+//# sourceMappingURL=group-session-builder.js.map

package/lib/Signal/Group/group_cipher.js

@@ -0,0 +1,84 @@
+//=======================================================//
+import { decrypt, encrypt } from "libsignal-xeuka/src/crypto.js";
+import { SenderKeyMessage } from "./sender-key-message.js";
+import { SenderKeyRecord } from "./sender-key-record.js";
+import { SenderKeyState } from "./sender-key-state.js";
+import { SenderKeyName } from "./sender-key-name.js";
+//=======================================================//
+export class GroupCipher {
+  constructor(senderKeyStore, senderKeyName) {
+    this.senderKeyStore = senderKeyStore;
+    this.senderKeyName = senderKeyName;
+  }
+  async encrypt(paddedPlaintext) {
+    const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+    if (!record) {
+      throw new Error("No SenderKeyRecord found for encryption");
+    }
+    const senderKeyState = record.getSenderKeyState();
+    if (!senderKeyState) {
+      throw new Error("No session to encrypt message");
+    }
+    const iteration = senderKeyState.getSenderChainKey().getIteration();
+    const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+    const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+    const senderKeyMessage = new SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+    await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+    return senderKeyMessage.serialize();
+  }
+  async decrypt(senderKeyMessageBytes) {
+    const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+    if (!record) {
+      throw new Error("No SenderKeyRecord found for decryption");
+    }
+    const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+    const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+    if (!senderKeyState) {
+      throw new Error("No session found to decrypt message");
+    }
+    senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+    const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+    const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+    await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+    return plaintext;
+  }
+  getSenderKey(senderKeyState, iteration) {
+    let senderChainKey = senderKeyState.getSenderChainKey();
+    if (senderChainKey.getIteration() > iteration) {
+      if (senderKeyState.hasSenderMessageKey(iteration)) {
+        const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+        if (!messageKey) {
+          throw new Error("No sender message key found for iteration");
+        }
+        return messageKey;
+      }
+      throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`);
+    }
+    if (iteration - senderChainKey.getIteration() > 2000) {
+      throw new Error("Over 2000 messages into the future!");
+    }
+    while (senderChainKey.getIteration() < iteration) {
+      senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+      senderChainKey = senderChainKey.getNext();
+    }
+    senderKeyState.setSenderChainKey(senderChainKey.getNext());
+    return senderChainKey.getSenderMessageKey();
+  }
+  async getPlainText(iv, key, ciphertext) {
+    try {
+      return decrypt(key, ciphertext, iv);
+    }
+    catch (e) {
+      throw new Error("InvalidMessageException");
+    }
+  }
+  async getCipherText(iv, key, plaintext) {
+    try {
+      return encrypt(key, plaintext, iv);
+    }
+    catch (e) {
+      throw new Error("InvalidMessageException");
+    }
+  }
+}
+//=======================================================//

package/lib/Signal/Group/index.js

@@ -0,0 +1,13 @@
+//=======================================================//
+export { SenderKeyDistributionMessage } from "./sender-key-distribution-message.js";
+export { GroupSessionBuilder } from "./group-session-builder.js";
+export { CiphertextMessage } from "./ciphertext-message.js";
+export { SenderKeyMessage } from "./sender-key-message.js";
+export { SenderMessageKey } from "./sender-message-key.js";
+export { SenderKeyRecord } from "./sender-key-record.js";
+export { SenderKeyState } from "./sender-key-state.js";
+export { SenderChainKey } from "./sender-chain-key.js";
+export { SenderKeyName } from "./sender-key-name.js";
+export { GroupCipher } from "./group_cipher.js";
+export * as keyhelper from "./keyhelper.js";
+//=======================================================//

package/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,20 @@
+//=======================================================//
+import { generateKeyPair } from "libsignal-xeuka/src/curve.js";
+import * as nodeCrypto from "crypto";
+//=======================================================//
+export function generateSenderKey() {
+  return nodeCrypto.randomBytes(32);
+}
+export function generateSenderKeyId() {
+  return nodeCrypto.randomInt(2147483647);
+}
+export function generateSenderSigningKey(key) {
+  if (!key) {
+    key = generateKeyPair();
+  }
+  return {
+    public: Buffer.from(key.pubKey),
+    private: Buffer.from(key.privKey)
+  };
+}
+//=======================================================// 

package/lib/Signal/Group/sender-chain-key.js

@@ -0,0 +1,28 @@
+//=======================================================//
+import { calculateMAC } from "libsignal-xeuka/src/crypto.js";
+import { SenderMessageKey } from "./sender-message-key.js";
+//=======================================================//
+export class SenderChainKey {
+  constructor(iteration, chainKey) {
+    this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
+    this.CHAIN_KEY_SEED = Buffer.from([0x02]);
+    this.iteration = iteration;
+    this.chainKey = Buffer.from(chainKey);
+  }
+  getIteration() {
+    return this.iteration;
+  }
+  getSenderMessageKey() {
+    return new SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey));
+  }
+  getNext() {
+    return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey));
+  }
+  getSeed() {
+    return this.chainKey;
+  }
+  getDerivative(seed, key) {
+    return calculateMAC(key, seed);
+  }
+}
+//=======================================================//

package/lib/Signal/Group/sender-key-distribution-message.js

@@ -0,0 +1,65 @@
+//=======================================================//
+import { CiphertextMessage } from "./ciphertext-message.js";
+import { proto } from "../../../WAProto/index.js";
+//=======================================================//
+export class SenderKeyDistributionMessage extends CiphertextMessage {
+  constructor(id, iteration, chainKey, signatureKey, serialized) {
+    super();
+    if (serialized) {
+      try {
+        const message = serialized.slice(1);
+        const distributionMessage = proto.SenderKeyDistributionMessage.decode(message).toJSON();
+        this.serialized = serialized;
+        this.id = distributionMessage.id;
+        this.iteration = distributionMessage.iteration;
+        this.chainKey =
+          typeof distributionMessage.chainKey === "string"
+            ? Buffer.from(distributionMessage.chainKey, "base64")
+            : distributionMessage.chainKey;
+        this.signatureKey =
+          typeof distributionMessage.signingKey === "string"
+            ? Buffer.from(distributionMessage.signingKey, "base64")
+            : distributionMessage.signingKey;
+      }
+      catch (e) {
+        throw new Error(String(e));
+      }
+    }
+    else {
+      const version = this.intsToByteHighAndLow(this.CURRENT_VERSION, this.CURRENT_VERSION);
+      this.id = id;
+      this.iteration = iteration;
+      this.chainKey = chainKey;
+      this.signatureKey = signatureKey;
+      const message = proto.SenderKeyDistributionMessage.encode(proto.SenderKeyDistributionMessage.create({
+        id,
+        iteration,
+        chainKey,
+        signingKey: this.signatureKey
+      })).finish();
+      this.serialized = Buffer.concat([Buffer.from([version]), message]);
+    }
+  }
+  intsToByteHighAndLow(highValue, lowValue) {
+    return (((highValue << 4) | lowValue) & 0xff) % 256;
+  }
+  serialize() {
+    return this.serialized;
+  }
+  getType() {
+    return this.SENDERKEY_DISTRIBUTION_TYPE;
+  }
+  getIteration() {
+    return this.iteration;
+  }
+  getChainKey() {
+    return this.chainKey;
+  }
+  getSignatureKey() {
+    return this.signatureKey;
+  }
+  getId() {
+    return this.id;
+  }
+}
+//=======================================================//

package/lib/Signal/Group/sender-key-message.js

@@ -0,0 +1,68 @@
+//=======================================================//
+import { calculateSignature, verifySignature } from "libsignal-xeuka/src/curve.js";
+import { CiphertextMessage } from "./ciphertext-message.js";
+import { proto } from "../../../WAProto/index.js";
+//=======================================================//
+export class SenderKeyMessage extends CiphertextMessage {
+  constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
+    super();
+    this.SIGNATURE_LENGTH = 64;
+    if (serialized) {
+      const version = serialized[0];
+      const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
+      const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
+      const senderKeyMessage = proto.SenderKeyMessage.decode(message).toJSON();
+      this.serialized = serialized;
+      this.messageVersion = (version & 0xff) >> 4;
+      this.keyId = senderKeyMessage.id;
+      this.iteration = senderKeyMessage.iteration;
+      this.ciphertext =
+        typeof senderKeyMessage.ciphertext === "string"
+          ? Buffer.from(senderKeyMessage.ciphertext, "base64")
+          : senderKeyMessage.ciphertext;
+      this.signature = signature;
+    }
+    else {
+      const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
+      const ciphertextBuffer = Buffer.from(ciphertext);
+      const message = proto.SenderKeyMessage.encode(proto.SenderKeyMessage.create({
+        id: keyId,
+        iteration: iteration,
+        ciphertext: ciphertextBuffer
+      })).finish();
+      const signature = this.getSignature(signatureKey, Buffer.concat([Buffer.from([version]), message]));
+      this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)]);
+      this.messageVersion = this.CURRENT_VERSION;
+      this.keyId = keyId;
+      this.iteration = iteration;
+      this.ciphertext = ciphertextBuffer;
+      this.signature = signature;
+    }
+  }
+  getKeyId() {
+    return this.keyId;
+  }
+  getIteration() {
+    return this.iteration;
+  }
+  getCipherText() {
+    return this.ciphertext;
+  }
+  verifySignature(signatureKey) {
+    const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
+    const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
+    const res = verifySignature(signatureKey, part1, part2);
+    if (!res)
+      throw new Error("Invalid signature!");
+  }
+  getSignature(signatureKey, serialized) {
+    return Buffer.from(calculateSignature(signatureKey, serialized));
+  }
+  serialize() {
+    return this.serialized;
+  }
+  getType() {
+    return 4;
+  }
+}
+//=======================================================//