@pontalabs/baileys 1.0.6 → 1.0.8

package/lib/Signal/Group/group_cipher.js

@@ -1,82 +1,111 @@
-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 {
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("libsignal/src/crypto")
+const sender_key_message_1 = require("./sender-key-message")
+
+class GroupCipher {
     constructor(senderKeyStore, senderKeyName) {
-        this.senderKeyStore = senderKeyStore;
-        this.senderKeyName = senderKeyName;
+        this.senderKeyStore = senderKeyStore
+        this.senderKeyName = senderKeyName
     }
     async encrypt(paddedPlaintext) {
-        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName)
+        
         if (!record) {
-            throw new Error('No SenderKeyRecord found for encryption');
+            throw new Error('No SenderKeyRecord found for encryption')
         }
-        const senderKeyState = record.getSenderKeyState();
+        
+        const senderKeyState = record.getSenderKeyState()
+        
         if (!senderKeyState) {
-            throw new Error('No session to encrypt message');
+            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();
+        
+        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()
     }
     async decrypt(senderKeyMessageBytes) {
-        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName)
+        
         if (!record) {
-            throw new Error('No SenderKeyRecord found for decryption');
+            throw new Error('No SenderKeyRecord found for decryption')
         }
-        const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
-        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+        
+        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();
+        let senderChainKey = senderKeyState.getSenderChainKey()
+        
         if (senderChainKey.getIteration() > iteration) {
             if (senderKeyState.hasSenderMessageKey(iteration)) {
-                const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+                const messageKey = senderKeyState.removeSenderMessageKey(iteration)
+                
                 if (!messageKey) {
-                    throw new Error('No sender message key found for iteration');
+                    throw new Error('No sender message key found for iteration')
                 }
-                return messageKey;
+                
+                return messageKey
             }
-            throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`);
+            
+            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.addSenderMessageKey(senderChainKey.getSenderMessageKey())
+            senderChainKey = senderChainKey.getNext()
         }
-        senderKeyState.setSenderChainKey(senderChainKey.getNext());
-        return senderChainKey.getSenderMessageKey();
+        
+        senderKeyState.setSenderChainKey(senderChainKey.getNext())
+        
+        return senderChainKey.getSenderMessageKey()
     }
     async getPlainText(iv, key, ciphertext) {
         try {
-            return decrypt(key, ciphertext, iv);
+            return crypto_1.decrypt(key, ciphertext, iv)
         }
         catch (e) {
-            throw new Error('InvalidMessageException');
+            throw new Error('InvalidMessageException')
         }
     }
     async getCipherText(iv, key, plaintext) {
         try {
-            return encrypt(key, plaintext, iv);
+            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 crypto_1.encrypt(keyBuffer, plaintextBuffer, ivBuffer)
         }
         catch (e) {
-            throw new Error('InvalidMessageException');
+            throw new Error('InvalidMessageException')
         }
     }
 }
-//# sourceMappingURL=group_cipher.js.map
+
+module.exports = {
+  GroupCipher
+}

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

@@ -1,12 +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';
-//# sourceMappingURL=index.d.ts.map
+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,12 +1,61 @@
-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';
-//# sourceMappingURL=index.js.map
+"use strict"
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    var desc = Object.getOwnPropertyDescriptor(m, k)
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k] } }
+    }
+    Object.defineProperty(o, k2, desc)
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    o[k2] = m[k]
+}))
+
+var __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

@@ -1,11 +1,16 @@
-import { generateKeyPair } from 'libsignal/src/curve.js';
-type KeyPairType = ReturnType<typeof generateKeyPair>;
-export declare function generateSenderKey(): Buffer;
-export declare function generateSenderKeyId(): number;
+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;
+    public: Buffer
+    private: Buffer
 }
-export declare function generateSenderSigningKey(key?: KeyPairType): SigningKeyPair;
-export {};
-//# sourceMappingURL=keyhelper.d.ts.map
+
+export declare function generateSenderSigningKey(key?: KeyPairType): SigningKeyPair
+
+export {}

package/lib/Signal/Group/keyhelper.js

@@ -1,18 +1,66 @@
-import * as nodeCrypto from 'crypto';
-import { generateKeyPair } from 'libsignal/src/curve.js';
-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 })
+
+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) {
+
+function generateSenderSigningKey(key) {
     if (!key) {
-        key = generateKeyPair();
+        key = curve_1.generateKeyPair()
     }
     return {
         public: Buffer.from(key.pubKey),
         private: Buffer.from(key.privKey)
-    };
+    }
 }
-//# sourceMappingURL=keyhelper.js.map
+
+module.exports = {
+  generateSenderKey, 
+  generateSenderKeyId, 
+  generateSenderSigningKey
+}

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

@@ -1,14 +1,14 @@
-import { SenderMessageKey } from './sender-message-key.js';
+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: Uint8Array | Buffer);
-    getIteration(): number;
-    getSenderMessageKey(): SenderMessageKey;
-    getNext(): SenderChainKey;
-    getSeed(): Uint8Array;
-    private getDerivative;
-}
-//# sourceMappingURL=sender-chain-key.d.ts.map
+    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,26 +1,47 @@
-import { calculateMAC } from 'libsignal/src/crypto.js';
-import { SenderMessageKey } from './sender-message-key.js';
-export class SenderChainKey {
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+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;
-        this.chainKey = Buffer.from(chainKey);
+        this.MESSAGE_KEY_SEED = Buffer.from([0x01])
+        this.CHAIN_KEY_SEED = Buffer.from([0x02])
+        this.iteration = iteration
+        if (Buffer.isBuffer(chainKey)) {
+        	// backported from @MartinSchere's PR
+            this.chainKey = chainKey
+        }
+        else if (chainKey instanceof Uint8Array) {
+            this.chainKey = Buffer.from(chainKey) 
+        }
+        else if (chainKey && typeof chainKey === 'object') {
+            // backported from @MartinSchere (#1741)
+            this.chainKey = Buffer.from(Object.values(chainKey)) // temp fix // backported from @MartinSchere (#1741)
+        }
+        else {
+            this.chainKey = Buffer.alloc(0)
+        }
     }
     getIteration() {
-        return this.iteration;
+        return this.iteration
     }
     getSenderMessageKey() {
-        return new SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey));
+        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));
+        return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey))
     }
     getSeed() {
-        return this.chainKey;
+        return this.chainKey
     }
     getDerivative(seed, key) {
-        return calculateMAC(key, seed);
+        return (0, crypto_1.calculateMAC)(key, seed)
     }
 }
-//# sourceMappingURL=sender-chain-key.js.map
+
+module.exports = {
+  SenderChainKey
+}

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

@@ -1,17 +1,17 @@
-import { CiphertextMessage } from './ciphertext-message.js';
+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;
-}
-//# sourceMappingURL=sender-key-distribution-message.d.ts.map
+    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
+}

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

@@ -1,63 +1,71 @@
-import { proto } from '../../../WAProto/index.js';
-import { CiphertextMessage } from './ciphertext-message.js';
-export class SenderKeyDistributionMessage extends CiphertextMessage {
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const WAProto_1 = require("../../../WAProto")
+const ciphertext_message_1 = require("./ciphertext-message")
+
+class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessage {
     constructor(id, iteration, chainKey, signatureKey, serialized) {
-        super();
+        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;
+                const message = serialized.slice(1)
+                const distributionMessage = WAProto_1.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;
+                        : distributionMessage.chainKey
                 this.signatureKey =
                     typeof distributionMessage.signingKey === 'string'
                         ? Buffer.from(distributionMessage.signingKey, 'base64')
-                        : distributionMessage.signingKey;
+                        : distributionMessage.signingKey
             }
             catch (e) {
-                throw new Error(String(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({
+            const version = this.intsToByteHighAndLow(this.CURRENT_VERSION, this.CURRENT_VERSION)
+            this.id = id
+            this.iteration = iteration
+            this.chainKey = chainKey
+            this.signatureKey = signatureKey
+            const message = WAProto_1.proto.SenderKeyDistributionMessage.encode(WAProto_1.proto.SenderKeyDistributionMessage.create({
                 id,
                 iteration,
                 chainKey,
                 signingKey: this.signatureKey
-            })).finish();
-            this.serialized = Buffer.concat([Buffer.from([version]), message]);
+            })).finish()
+            this.serialized = Buffer.concat([Buffer.from([version]), message])
         }
     }
     intsToByteHighAndLow(highValue, lowValue) {
-        return (((highValue << 4) | lowValue) & 0xff) % 256;
+        return (((highValue << 4) | lowValue) & 0xff) % 256
     }
     serialize() {
-        return this.serialized;
+        return this.serialized
     }
     getType() {
-        return this.SENDERKEY_DISTRIBUTION_TYPE;
+        return this.SENDERKEY_DISTRIBUTION_TYPE
     }
     getIteration() {
-        return this.iteration;
+        return this.iteration
     }
     getChainKey() {
-        return this.chainKey;
+        return typeof this.chainKey === 'string' ? Buffer.from(this.chainKey, 'base64') : this.chainKey
     }
     getSignatureKey() {
-        return this.signatureKey;
+        return typeof this.signatureKey === 'string' ? Buffer.from(this.signatureKey, 'base64') : this.signatureKey
     }
     getId() {
-        return this.id;
+        return this.id
     }
 }
-//# sourceMappingURL=sender-key-distribution-message.js.map
+
+module.exports = {
+  SenderKeyDistributionMessage
+}

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

@@ -1,19 +1,19 @@
-import { CiphertextMessage } from './ciphertext-message.js';
+import { CiphertextMessage } from './ciphertext-message'
+
 export declare class SenderKeyMessage extends CiphertextMessage {
-    private readonly SIGNATURE_LENGTH;
-    private readonly messageVersion;
-    private readonly keyId;
-    private readonly iteration;
-    private readonly ciphertext;
-    private readonly signature;
-    private readonly serialized;
-    constructor(keyId?: number | null, iteration?: number | null, ciphertext?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null);
-    getKeyId(): number;
-    getIteration(): number;
-    getCipherText(): Uint8Array;
-    verifySignature(signatureKey: Uint8Array): void;
-    private getSignature;
-    serialize(): Uint8Array;
-    getType(): number;
-}
-//# sourceMappingURL=sender-key-message.d.ts.map
+    private readonly SIGNATURE_LENGTH
+    private readonly messageVersion
+    private readonly keyId
+    private readonly iteration
+    private readonly ciphertext
+    private readonly signature
+    private readonly serialized
+    constructor(keyId?: number | null, iteration?: number | null, ciphertext?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null)
+    getKeyId(): number
+    getIteration(): number
+    getCipherText(): Uint8Array
+    verifySignature(signatureKey: Uint8Array): void
+    private getSignature
+    serialize(): Uint8Array
+    getType(): number
+}