@sgintokic/baileys 0.0.2

package/engine-requirements.js

@@ -0,0 +1 @@
+const major=parseInt(process.versions.node.split(".")[0],10);if(major<20){console.error(`\n❌ This package requires Node.js 20+ to run reliably.\n`+`   You are using Node.js ${process.versions.node}.\n`+`   Please upgrade to Node.js 20+ to proceed.\n`);process.exit(1)}

package/lib/Defaults/index.js

@@ -0,0 +1,155 @@
+import { createHash, randomBytes } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { makeLibSignalRepository } from '../Signal/libsignal.js';
+import { Browsers } from '../Utils/browser-utils.js';
+import logger from '../Utils/logger.js';
+const version = [2, 3e3, 1035194821];
+export const UNAUTHORIZED_CODES = [401, 403, 419];
+export const BIZ_BOT_SUPPORT_PAYLOAD =
+	'{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
+export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
+export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
+export const CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
+export const DEF_CALLBACK_PREFIX = 'CB:';
+export const DEF_TAG_PREFIX = 'TAG:';
+
+export const PHONE_CONNECTION_CB = 'CB:Pong';
+export const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+export const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+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 WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+/** Status messages older than 24 hours are considered expired */ export const STATUS_EXPIRY_SECONDS = 24 * 60 * 60;
+/** WA Web enforces a 14-day maximum age for placeholder resend requests */ export const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 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"
+/** 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,
+	ISSUER: 'WhatsAppLongTerm1',
+	PUBLIC_KEY: Buffer.from('142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b', 'hex')
+};
+export const PROCESSABLE_HISTORY_TYPES = [
+	proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
+	proto.HistorySync.HistorySyncType.PUSH_NAME,
+	proto.HistorySync.HistorySyncType.RECENT,
+	proto.HistorySync.HistorySyncType.FULL,
+	proto.HistorySync.HistorySyncType.ON_DEMAND,
+	proto.HistorySync.HistorySyncType.NON_BLOCKING_DATA,
+	proto.HistorySync.HistorySyncType.INITIAL_STATUS_V3
+];
+export const DEFAULT_CONNECTION_CONFIG = {
+	version: version,
+	browser: Browsers.macOS('Chrome'),
+	waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
+	connectTimeoutMs: 2e4,
+	keepAliveIntervalMs: 3e4,
+	logger: logger.child({ class: 'baileys' }),
+	emitOwnEvents: true,
+	defaultQueryTimeoutMs: 6e4,
+	customUploadHosts: [],
+	retryRequestDelayMs: 250,
+	maxMsgRetryCount: 3,
+	fireInitQueries: true,
+	auth: undefined,
+	markOnlineOnConnect: true,
+	syncFullHistory: true,
+	patchMessageBeforeSending: msg => msg,
+	shouldSyncHistoryMessage: ({ syncType }) => {
+		return syncType !== proto.HistorySync.HistorySyncType.FULL;
+	},
+	shouldIgnoreJid: () => false,
+	linkPreviewImageThumbnailWidth: 192,
+	transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3e3 },
+	generateHighQualityLinkPreview: false,
+	enableAutoSessionRecreation: true,
+	enableRecentMessageCache: true,
+	options: {},
+	generateMessageID: () => 'GIN4B0T' + randomBytes(11).toString('hex').toUpperCase(),
+	generateMessageIDV2: userId => {
+		if (!userId) {
+			userId = randomBytes(32).toString('hex');
+		}
+		const hash = createHash('sha256').update(userId).digest('hex').toUpperCase();
+		const randomPart = randomBytes(11).toString('hex').toUpperCase();
+		const combined = hash + randomPart;
+		let result = '';
+		for (let i = 0; i < 25; i++) {
+			const randomIndex = randomBytes(1)[0] % combined.length;
+			result += combined[randomIndex];
+		}
+		return 'G1N4B0T' + result;
+	},
+
+	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',
+	'sticker-pack': '/mms/sticker-pack',
+	'thumbnail-sticker-pack': '/mms/thumbnail-sticker-pack',
+	'thumbnail-link': '/mms/thumbnail-link',
+	'product-catalog-image': '/product/image',
+	'md-app-state': '',
+	'md-msg-hist': '/mms/md-app-state',
+	'biz-cover-photo': '/pps/biz-cover-photo'
+};
+// Lia@Changes 06-02-26 --- Add newsletter media path for "/m1/" instead of "/o1/" (⁠≧⁠▽⁠≦⁠)
+export const NEWSLETTER_MEDIA_PATH_MAP = {
+	image: '/newsletter/newsletter-image',
+	video: '/newsletter/newsletter-video',
+	document: '/newsletter/newsletter-document',
+	audio: '/newsletter/newsletter-audio',
+	sticker: '/newsletter/newsletter-image',
+	'thumbnail-link': '/newsletter/newsletter-thumbnail-link'
+};
+export const MEDIA_HKDF_KEY_MAPPING = {
+	audio: 'Audio',
+	document: 'Document',
+	gif: 'Video',
+	image: 'Image',
+	ppic: '',
+	product: 'Image',
+	ptt: 'Audio',
+	'sticker-pack': 'Sticker Pack',
+	'thumbnail-sticker-pack': 'Sticker Pack Thumbnail',
+	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 = 3e4; // 30 seconds
+export const MIN_UPLOAD_INTERVAL = 5e3; // 5 seconds minimum between uploads
+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
+};
+export const TimeMs = {
+	Minute: 60 * 1e3,
+	Hour: 60 * 60 * 1e3,
+	Day: 24 * 60 * 60 * 1e3,
+	Week: 7 * 24 * 60 * 60 * 1e3
+};

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

@@ -0,0 +1,11 @@
+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,41 @@
+import * as keyhelper from "./keyhelper.js";
+import { SenderKeyDistributionMessage } from "./sender-key-distribution-message.js";
+import { SenderKeyName } from "./sender-key-name.js";
+import { SenderKeyRecord } from "./sender-key-record.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(),
+    );
+  }
+}

package/lib/Signal/Group/group_cipher.js

@@ -0,0 +1,108 @@
+import { decrypt, encrypt } from "libsignal/src/crypto.js";
+import { SenderKeyMessage } from "./sender-key-message.js";
+import { SenderKeyName } from "./sender-key-name.js";
+import { SenderKeyRecord } from "./sender-key-record.js";
+import { SenderKeyState } from "./sender-key-state.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() > 2e3) {
+      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,11 @@
+export { GroupSessionBuilder } from "./group-session-builder.js";
+export { SenderKeyDistributionMessage } from "./sender-key-distribution-message.js";
+export { SenderKeyRecord } from "./sender-key-record.js";
+export { SenderKeyName } from "./sender-key-name.js";
+export { GroupCipher } from "./group_cipher.js";
+export { SenderKeyState } from "./sender-key-state.js";
+export { SenderKeyMessage } from "./sender-key-message.js";
+export { SenderMessageKey } from "./sender-message-key.js";
+export { SenderChainKey } from "./sender-chain-key.js";
+export { CiphertextMessage } from "./ciphertext-message.js";
+export * as keyhelper from "./keyhelper.js";

package/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,14 @@
+import * as nodeCrypto from "crypto";
+import { generateKeyPair } from "libsignal/src/curve.js";
+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,31 @@
+import { calculateMAC } from "libsignal/src/crypto.js";
+import { SenderMessageKey } from "./sender-message-key.js";
+export class SenderChainKey {
+  constructor(iteration, chainKey) {
+    this.MESSAGE_KEY_SEED = Buffer.from([1]);
+    this.CHAIN_KEY_SEED = Buffer.from([2]);
+    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,66 @@
+import { proto } from "../../../WAProto/index.js";
+import { CiphertextMessage } from "./ciphertext-message.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: id,
+          iteration: iteration,
+          chainKey: chainKey,
+          signingKey: this.signatureKey,
+        }),
+      ).finish();
+      this.serialized = Buffer.concat([Buffer.from([version]), message]);
+    }
+  }
+  intsToByteHighAndLow(highValue, lowValue) {
+    return (((highValue << 4) | lowValue) & 255) % 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,79 @@
+import { calculateSignature, verifySignature } from "libsignal/src/curve.js";
+import { proto } from "../../../WAProto/index.js";
+import { CiphertextMessage } from "./ciphertext-message.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 & 255) >> 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) & 255) % 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;
+  }
+}

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

@@ -0,0 +1,49 @@
+function isNull(str) {
+  return str === null || str === "";
+}
+function intValue(num) {
+  const MAX_VALUE = 2147483647;
+  const MIN_VALUE = -2147483648;
+  if (num > MAX_VALUE || num < MIN_VALUE) {
+    return num & 4294967295;
+  }
+  return num;
+}
+function hashCode(strKey) {
+  let hash = 0;
+  if (!isNull(strKey)) {
+    for (let i = 0; i < strKey.length; i++) {
+      hash = hash * 31 + strKey.charCodeAt(i);
+      hash = intValue(hash);
+    }
+  }
+  return hash;
+}
+export class SenderKeyName {
+  constructor(groupId, sender) {
+    this.groupId = groupId;
+    this.sender = sender;
+  }
+  getGroupId() {
+    return this.groupId;
+  }
+  getSender() {
+    return this.sender;
+  }
+  serialize() {
+    return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`;
+  }
+  toString() {
+    return this.serialize();
+  }
+  equals(other) {
+    if (other === null) return false;
+    return (
+      this.groupId === other.groupId &&
+      this.sender.toString() === other.sender.toString()
+    );
+  }
+  hashCode() {
+    return hashCode(this.groupId) ^ hashCode(this.sender.toString());
+  }
+}

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

@@ -0,0 +1,46 @@
+import { BufferJSON } from "../../Utils/generics.js";
+import { SenderKeyState } from "./sender-key-state.js";
+export class SenderKeyRecord {
+  constructor(serialized) {
+    this.MAX_STATES = 5;
+    this.senderKeyStates = [];
+    if (serialized) {
+      for (const structure of serialized) {
+        this.senderKeyStates.push(
+          new SenderKeyState(null, null, null, null, null, null, structure),
+        );
+      }
+    }
+  }
+  isEmpty() {
+    return this.senderKeyStates.length === 0;
+  }
+  getSenderKeyState(keyId) {
+    if (keyId === undefined && this.senderKeyStates.length) {
+      return this.senderKeyStates[this.senderKeyStates.length - 1];
+    }
+    return this.senderKeyStates.find((state) => state.getKeyId() === keyId);
+  }
+  addSenderKeyState(id, iteration, chainKey, signatureKey) {
+    this.senderKeyStates.push(
+      new SenderKeyState(id, iteration, chainKey, null, signatureKey),
+    );
+    if (this.senderKeyStates.length > this.MAX_STATES) {
+      this.senderKeyStates.shift();
+    }
+  }
+  setSenderKeyState(id, iteration, chainKey, keyPair) {
+    this.senderKeyStates.length = 0;
+    this.senderKeyStates.push(
+      new SenderKeyState(id, iteration, chainKey, keyPair),
+    );
+  }
+  serialize() {
+    return this.senderKeyStates.map((state) => state.getStructure());
+  }
+  static deserialize(data) {
+    const str = Buffer.from(data).toString("utf-8");
+    const parsed = JSON.parse(str, BufferJSON.reviver);
+    return new SenderKeyRecord(parsed);
+  }
+}