@skyzopedia/baileys-mod 5.0.7 → 6.0.0

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

@@ -1,10 +1,42 @@
-//=======================================================//
-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 {
+"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.GroupSessionBuilder = void 0;
+const keyhelper = __importStar(require("./keyhelper"));
+const sender_key_distribution_message_1 = require("./sender-key-distribution-message");
+class GroupSessionBuilder {
     constructor(senderKeyStore) {
         this.senderKeyStore = senderKeyStore;
     }
@@ -24,9 +56,9 @@ export class GroupSessionBuilder {
         }
         const state = senderKeyRecord.getSenderKeyState();
         if (!state) {
-            throw new Error("No session state available");
+            throw new Error('No session state available');
         }
-        return new SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
+        return new sender_key_distribution_message_1.SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
     }
 }
-//# sourceMappingURL=group-session-builder.js.map
+exports.GroupSessionBuilder = GroupSessionBuilder;

package/lib/Signal/Group/group_cipher.d.ts

@@ -0,0 +1,17 @@
+import { SenderKeyName } from './sender-key-name';
+import { SenderKeyRecord } from './sender-key-record';
+export interface SenderKeyStore {
+    loadSenderKey(senderKeyName: SenderKeyName): Promise<SenderKeyRecord>;
+    storeSenderKey(senderKeyName: SenderKeyName, record: SenderKeyRecord): Promise<void>;
+}
+export declare class GroupCipher {
+    private readonly senderKeyStore;
+    private readonly senderKeyName;
+    constructor(senderKeyStore: SenderKeyStore, senderKeyName: SenderKeyName);
+    private queueJob;
+    encrypt(paddedPlaintext: Uint8Array | string): Promise<Uint8Array>;
+    decrypt(senderKeyMessageBytes: Uint8Array): Promise<Uint8Array>;
+    private getSenderKey;
+    private getPlainText;
+    private getCipherText;
+}

package/lib/Signal/Group/group_cipher.js

@@ -1,84 +1,96 @@
-//=======================================================//
-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");
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCipher = void 0;
+const crypto_1 = require("libsignal/src/crypto");
+const queue_job_1 = __importDefault(require("./queue-job"));
+const sender_key_message_1 = require("./sender-key-message");
+class GroupCipher {
+    constructor(senderKeyStore, senderKeyName) {
+        this.senderKeyStore = senderKeyStore;
+        this.senderKeyName = senderKeyName;
     }
-    const senderKeyState = record.getSenderKeyState();
-    if (!senderKeyState) {
-      throw new Error("No session to encrypt message");
+    queueJob(awaitable) {
+        return (0, queue_job_1.default)(this.senderKeyName.toString(), awaitable);
     }
-    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");
+    async encrypt(paddedPlaintext) {
+        return await this.queueJob(async () => {
+            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 sender_key_message_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+            await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+            return senderKeyMessage.serialize();
+        });
     }
-    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");
+    async decrypt(senderKeyMessageBytes) {
+        return await this.queueJob(async () => {
+            const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+            if (!record) {
+                throw new Error('No SenderKeyRecord found for decryption');
+            }
+            const senderKeyMessage = new sender_key_message_1.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;
+        });
     }
-    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");
+    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}`);
         }
-        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");
+        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 getCipherText(iv, key, plaintext) {
-    try {
-      return encrypt(key, plaintext, iv);
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return (0, crypto_1.decrypt)(key, ciphertext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
     }
-    catch (e) {
-      throw new Error("InvalidMessageException");
+    async getCipherText(iv, key, plaintext) {
+        try {
+            const ivBuffer = typeof iv === 'string' ? Buffer.from(iv, 'base64') : iv;
+            const keyBuffer = typeof key === 'string' ? Buffer.from(key, 'base64') : key;
+            const plaintextBuffer = typeof plaintext === 'string' ? Buffer.from(plaintext) : plaintext;
+            return (0, crypto_1.encrypt)(keyBuffer, plaintextBuffer, ivBuffer);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
     }
-  }
 }
-//=======================================================//
+exports.GroupCipher = GroupCipher;

package/lib/Signal/Group/index.d.ts

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

package/lib/Signal/Group/index.js

@@ -1,13 +1,57 @@
-//=======================================================//
-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";
-//=======================================================//
+"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.keyhelper = exports.CiphertextMessage = exports.SenderChainKey = exports.SenderMessageKey = exports.SenderKeyMessage = exports.SenderKeyState = exports.GroupCipher = exports.SenderKeyName = exports.SenderKeyRecord = exports.SenderKeyDistributionMessage = exports.GroupSessionBuilder = void 0;
+var group_session_builder_1 = require("./group-session-builder");
+Object.defineProperty(exports, "GroupSessionBuilder", { enumerable: true, get: function () { return group_session_builder_1.GroupSessionBuilder; } });
+var sender_key_distribution_message_1 = require("./sender-key-distribution-message");
+Object.defineProperty(exports, "SenderKeyDistributionMessage", { enumerable: true, get: function () { return sender_key_distribution_message_1.SenderKeyDistributionMessage; } });
+var sender_key_record_1 = require("./sender-key-record");
+Object.defineProperty(exports, "SenderKeyRecord", { enumerable: true, get: function () { return sender_key_record_1.SenderKeyRecord; } });
+var sender_key_name_1 = require("./sender-key-name");
+Object.defineProperty(exports, "SenderKeyName", { enumerable: true, get: function () { return sender_key_name_1.SenderKeyName; } });
+var group_cipher_1 = require("./group_cipher");
+Object.defineProperty(exports, "GroupCipher", { enumerable: true, get: function () { return group_cipher_1.GroupCipher; } });
+var sender_key_state_1 = require("./sender-key-state");
+Object.defineProperty(exports, "SenderKeyState", { enumerable: true, get: function () { return sender_key_state_1.SenderKeyState; } });
+var sender_key_message_1 = require("./sender-key-message");
+Object.defineProperty(exports, "SenderKeyMessage", { enumerable: true, get: function () { return sender_key_message_1.SenderKeyMessage; } });
+var sender_message_key_1 = require("./sender-message-key");
+Object.defineProperty(exports, "SenderMessageKey", { enumerable: true, get: function () { return sender_message_key_1.SenderMessageKey; } });
+var sender_chain_key_1 = require("./sender-chain-key");
+Object.defineProperty(exports, "SenderChainKey", { enumerable: true, get: function () { return sender_chain_key_1.SenderChainKey; } });
+var ciphertext_message_1 = require("./ciphertext-message");
+Object.defineProperty(exports, "CiphertextMessage", { enumerable: true, get: function () { return ciphertext_message_1.CiphertextMessage; } });
+exports.keyhelper = __importStar(require("./keyhelper"));

package/lib/Signal/Group/keyhelper.d.ts

@@ -0,0 +1,10 @@
+import { generateKeyPair } from 'libsignal/src/curve';
+type KeyPairType = ReturnType<typeof generateKeyPair>;
+export declare function generateSenderKey(): Buffer;
+export declare function generateSenderKeyId(): number;
+export interface SigningKeyPair {
+    public: Buffer;
+    private: Buffer;
+}
+export declare function generateSenderSigningKey(key?: KeyPairType): SigningKeyPair;
+export {};

package/lib/Signal/Group/keyhelper.js

@@ -1,20 +1,55 @@
-//=======================================================//
-import { generateKeyPair } from "libsignal-xeuka/src/curve.js";
-import * as nodeCrypto from "crypto";
-//=======================================================//
-export function generateSenderKey() {
-  return nodeCrypto.randomBytes(32);
+"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.generateSenderKey = generateSenderKey;
+exports.generateSenderKeyId = generateSenderKeyId;
+exports.generateSenderSigningKey = generateSenderSigningKey;
+const nodeCrypto = __importStar(require("crypto"));
+const curve_1 = require("libsignal/src/curve");
+function generateSenderKey() {
+    return nodeCrypto.randomBytes(32);
 }
-export function generateSenderKeyId() {
-  return nodeCrypto.randomInt(2147483647);
+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)
-  };
+function generateSenderSigningKey(key) {
+    if (!key) {
+        key = (0, curve_1.generateKeyPair)();
+    }
+    return {
+        public: Buffer.from(key.pubKey),
+        private: Buffer.from(key.privKey)
+    };
 }
-//=======================================================// 

package/lib/Signal/Group/queue-job.d.ts

@@ -0,0 +1 @@
+export default function queueJob<T>(bucket: string | number, awaitable: () => Promise<T>): Promise<T>;

package/lib/Signal/Group/queue-job.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueJob;
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 10000;
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const limit = Math.min(queue.length, _gcLimit);
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            }
+            catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit);
+                offt = 0;
+            }
+            else {
+                offt = limit;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    cleanup();
+}
+function queueJob(bucket, awaitable) {
+    // Skip name assignment since it's readonly in strict mode
+    if (typeof bucket !== 'string') {
+        console.warn('Unhandled bucket type (for naming):', typeof bucket, bucket);
+    }
+    let inactive = false;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => {
+        queue.push({
+            awaitable,
+            resolve: resolve,
+            reject
+        });
+    });
+    if (inactive) {
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
+}

package/lib/Signal/Group/sender-chain-key.d.ts

@@ -0,0 +1,13 @@
+import { SenderMessageKey } from './sender-message-key';
+export declare class SenderChainKey {
+    private readonly MESSAGE_KEY_SEED;
+    private readonly CHAIN_KEY_SEED;
+    private readonly iteration;
+    private readonly chainKey;
+    constructor(iteration: number, chainKey: any);
+    getIteration(): number;
+    getSenderMessageKey(): SenderMessageKey;
+    getNext(): SenderChainKey;
+    getSeed(): Uint8Array;
+    private getDerivative;
+}

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

@@ -1,28 +1,34 @@
-//=======================================================//
-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);
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderChainKey = void 0;
+const crypto_1 = require("libsignal/src/crypto");
+const sender_message_key_1 = require("./sender-message-key");
+class SenderChainKey {
+    constructor(iteration, chainKey) {
+        this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
+        this.CHAIN_KEY_SEED = Buffer.from([0x02]);
+        this.iteration = iteration;
+        if (chainKey instanceof Buffer) {
+            this.chainKey = chainKey;
+        }
+        else {
+            this.chainKey = Buffer.from(chainKey || []);
+        }
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getSenderMessageKey() {
+        return new sender_message_key_1.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 (0, crypto_1.calculateMAC)(key, seed);
+    }
 }
-//=======================================================//
+exports.SenderChainKey = SenderChainKey;

package/lib/Signal/Group/sender-key-distribution-message.d.ts

@@ -0,0 +1,16 @@
+import { CiphertextMessage } from './ciphertext-message';
+export declare class SenderKeyDistributionMessage extends CiphertextMessage {
+    private readonly id;
+    private readonly iteration;
+    private readonly chainKey;
+    private readonly signatureKey;
+    private readonly serialized;
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null);
+    private intsToByteHighAndLow;
+    serialize(): Uint8Array;
+    getType(): number;
+    getIteration(): number;
+    getChainKey(): Uint8Array;
+    getSignatureKey(): Uint8Array;
+    getId(): number;
+}