@mrlegendbot/baileys 1.2.3 → 1.2.4

package/lib/Defaults/index.js

@@ -1,8 +1,10 @@
-import { proto } from '../../WAProto/index.js';
+import { createHash } from 'crypto';
+import { createRequire } from 'module';
+import { proto } from '../../WAProto/compiler.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1043857760];
+const version = [2, 3000, 1035194821];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
@@ -15,115 +17,110 @@ 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 NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]);
 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')
+  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 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_CACHE_TTLS = {
-    SIGNAL_STORE: 5 * 60, // 5 minutes
-    MSG_RETRY: 60 * 60, // 1 hour
-    CALL_OFFER: 5 * 60, // 5 minutes
-    USER_DEVICES: 5 * 60 // 5 minutes
+  SIGNAL_STORE: 5 * 60,
+  MSG_RETRY: 60 * 60,
+  CALL_OFFER: 5 * 60,
+  USER_DEVICES: 5 * 60
 };
 export const DEFAULT_CONNECTION_CONFIG = {
-    version: version,
-    browser: Browsers.macOS('Chrome'),
-    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: ({ syncType }) => {
-        return syncType !== proto.HistorySync.HistorySyncType.FULL;
-    },
-    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
+  version: version,
+  browser: Browsers.macOS('Chrome'),
+  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: ({
+    syncType
+  }) => {
+    return syncType !== proto.HistorySync.HistorySyncType.FULL;
+  },
+  shouldIgnoreJid: () => false,
+  ignoreOfflineMessages: 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'
+  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'
+  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);
-/** 120s timeout for history sync stall detection, same as WA Web's handleChunkProgress / restartPausedTimer (g = 120) */
 export const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120000;
 export const MIN_PREKEY_COUNT = 5;
 export const INITIAL_PREKEY_COUNT = 812;
-export const UPLOAD_TIMEOUT = 30000; // 30 seconds
+export const UPLOAD_TIMEOUT = 30000;
 export const TimeMs = {
-    Minute: 60 * 1000,
-    Hour: 60 * 60 * 1000,
-    Day: 24 * 60 * 60 * 1000,
-    Week: 7 * 24 * 60 * 60 * 1000
+  Minute: 60 * 1000,
+  Hour: 60 * 60 * 1000,
+  Day: 24 * 60 * 60 * 1000,
+  Week: 7 * 24 * 60 * 60 * 1000
 };
-//# sourceMappingURL=index.js.map

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

@@ -1,12 +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;
-    }
+  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;
+  }
 }
-//# sourceMappingURL=ciphertext-message.js.map

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

@@ -3,28 +3,27 @@ import { SenderKeyDistributionMessage } from './sender-key-distribution-message.
 import { SenderKeyName } from './sender-key-name.js';
 import { SenderKeyRecord } from './sender-key-record.js';
 export class GroupSessionBuilder {
-    constructor(senderKeyStore) {
-        this.senderKeyStore = senderKeyStore;
+  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);
     }
-    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());
+    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

@@ -1,82 +1,88 @@
-import { decrypt, encrypt } from 'libsignal/src/crypto.js';
+import { createCipheriv, createDecipheriv } from 'crypto';
 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;
+  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');
     }
-    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();
+    const senderKeyState = record.getSenderKeyState();
+    if (!senderKeyState) {
+      throw new Error('No session to encrypt message');
     }
-    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;
+    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');
     }
-    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();
+    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 getPlainText(iv, key, ciphertext) {
-        try {
-            return decrypt(key, ciphertext, iv);
-        }
-        catch (e) {
-            throw new Error('InvalidMessageException');
+    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}`);
     }
-    async getCipherText(iv, key, plaintext) {
-        try {
-            return encrypt(key, plaintext, 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 getPlainText(iv, key, ciphertext) {
+    try {
+      return aesDecryptWithIV(ciphertext, key, iv);
+    } catch (e) {
+      throw new Error('InvalidMessageException');
     }
+  }
+  async getCipherText(iv, key, plaintext) {
+    try {
+      return aesEncryptWithIV(plaintext, key, iv);
+    } catch (e) {
+      throw new Error('InvalidMessageException');
+    }
+  }
+}
+const toBuf = v => Buffer.isBuffer(v) ? v : Buffer.from(v.buffer ?? v, v.byteOffset ?? 0, v.byteLength ?? v.length);
+function aesDecryptWithIV(buffer, key, iv) {
+  const decipher = createDecipheriv('aes-256-cbc', toBuf(key), toBuf(iv));
+  return Buffer.concat([decipher.update(toBuf(buffer)), decipher.final()]);
+}
+function aesEncryptWithIV(buffer, key, iv) {
+  const cipher = createCipheriv('aes-256-cbc', toBuf(key), toBuf(iv));
+  return Buffer.concat([cipher.update(toBuf(buffer)), cipher.final()]);
 }
-//# sourceMappingURL=group_cipher.js.map

package/lib/Signal/Group/index.js

@@ -9,4 +9,3 @@ 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

package/lib/Signal/Group/keyhelper.js

@@ -1,18 +1,17 @@
 import * as nodeCrypto from 'crypto';
 import { generateKeyPair } from 'libsignal/src/curve.js';
 export function generateSenderKey() {
-    return nodeCrypto.randomBytes(32);
+  return nodeCrypto.randomBytes(32);
 }
 export function generateSenderKeyId() {
-    return nodeCrypto.randomInt(2147483647);
+  return nodeCrypto.randomInt(2147483647);
 }
 export function generateSenderSigningKey(key) {
-    if (!key) {
-        key = generateKeyPair();
-    }
-    return {
-        public: Buffer.from(key.pubKey),
-        private: Buffer.from(key.privKey)
-    };
+  if (!key) {
+    key = generateKeyPair();
+  }
+  return {
+    public: Buffer.from(key.pubKey),
+    private: Buffer.from(key.privKey)
+  };
 }
-//# sourceMappingURL=keyhelper.js.map

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

@@ -1,26 +1,25 @@
 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([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);
-    }
+  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);
+  }
 }
-//# sourceMappingURL=sender-chain-key.js.map

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

@@ -1,63 +1,54 @@
-import { proto } from '../../../WAProto/index.js';
+import { proto } from '../../../WAProto/compiler.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,
-                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;
-    }
+  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;
+  }
 }
-//# sourceMappingURL=sender-key-distribution-message.js.map