sauruspro-bail 0.0.0-stage → 5.0.0

package/docs/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## 5.0.0
+**Owner: Saurus / Dinolith**
+
+### Added
+- **Newsletter Status**: `sendNewsletterStatus`, `sendNewsletterStatusReaction`, `revokeNewsletterStatus`, `getNewsletterStatuses`, `getNewsletterStatusUpdates`, plus `sock.newsletter.{sendStatus, reactToStatus, revokeStatus, fetchStatuses, fetchStatusUpdates}`.
+- File tipe `newsletter-status.d.ts` dan `dinolith-spr.d.ts`.
+- Dokumentasi di folder `docs/`.
+- Export `sPR` / `selectiveRelay` dari entry utama.
+
+### Fixed
+- `dinolith-spr.js` mengimpor `encodeSignedDeviceIdentity` dari `generics.js` (tidak ada), sehingga seluruh paket gagal load. Sekarang dari `validate-connection.js`.
+- SPR: disamakan penuh dengan SPR diezyxhao-baileys 1.4.0 (logika identik, hanya CJS → ESM), termasuk fallback `conn.user` saat `authState.creds.me` kosong.
+- `package.json`: `"type": "module"` ditambahkan (kode ESM), duplikat `lru-cache` di devDependencies dihapus.
+
+### Changed
+- Versi `3.0.0` → `5.0.0`, author/owner `Saurus / Dinolith`.
+- README ditulis ulang, banner menampilkan versi & owner.
+
+### Notes
+- Newsletter status diport dari diezyxhao-baileys 1.4.0 ke ESM; tidak mengubah `sendMessage`.

package/docs/NEWSLETTER-STATUS.md

@@ -0,0 +1,120 @@
+# 📢 Newsletter Status
+
+Kirim, react, hapus, dan ambil **status Channel (newsletter)** WhatsApp.
+Tersedia sejak **v5.0.0**. Kamu harus **admin/owner** channel tersebut.
+
+Semua fungsi tersedia dalam 3 cara:
+
+| Cara | Contoh |
+|---|---|
+| `sock.newsletter.*` | `sock.newsletter.sendStatus(jid, content)` |
+| `sock.*` langsung | `sock.sendNewsletterStatus(jid, content)` |
+| Import factory | `makeNewsletterStatusSender(sock, config)` |
+
+JID newsletter harus berakhiran `@newsletter`, kalau tidak akan melempar `TypeError`.
+
+---
+
+## 1. Kirim status
+
+```js
+await sock.newsletter.sendStatus(jid, content, options?)
+// atau object style:
+await sock.newsletter.sendStatus({ jid, content, ...options })
+```
+
+### Content
+
+| Jenis | Contoh |
+|---|---|
+| Teks | `{ text: 'Halo' }` |
+| Gambar | `{ image: { url }, caption }` |
+| Video | `{ video: { url }, caption }` |
+| GIF | `{ video: { url }, gifPlayback: true }` |
+| Audio | `{ audio: { url }, mimetype: 'audio/mpeg' }` |
+
+Dokumen dan sticker **tidak didukung** (akan melempar error).
+Hanya `image` dan `video` yang dipublish WhatsApp Web sendiri; audio/gif bisa ditolak server (ada log warning).
+
+### Options
+
+| Option | Default | Keterangan |
+|---|---|---|
+| `messageId` | auto | ID pesan kustom |
+| `statusAttribution` | `true` | Tambah atribusi `NEWSLETTER_STATUS` + `canBeReshared` |
+| `interactionType` | - | `question` / `question_response` / `question_reshare` |
+| `parentServerId` | - | Wajib untuk `question_reshare` |
+| `responseServerId` | - | Wajib untuk `question_reshare` |
+| `aiContent` | - | Tandai konten AI |
+| `mediaHandle` / `mediaId` | auto | Handle media hasil upload |
+| `ackTimeoutMs` | `20000` | Timeout menunggu ack server |
+| `resolveServerId` | `true` | Tunggu echo server untuk dapat `serverId`. `false` = lebih cepat |
+| `serverIdTimeoutMs` | `8000` | Timeout menunggu echo |
+
+### Hasil
+
+Mengembalikan `WebMessageInfo` dengan field tambahan:
+
+```js
+{
+  newsletterStatusServerId, // number, dipakai untuk react/revoke
+  newsletterStatusAck,      // ack terurai
+  newsletterStatusResponse, // node mentah
+  newsletterStatusDelivered // node echo (jika resolveServerId)
+}
+```
+
+### Reshare status channel ke status sendiri
+
+```js
+await sock.newsletter.sendStatus(jid, {
+  text: 'Lihat ini',
+  newsletterStatus: { newsletterJid: '120363...@newsletter', messageId: 150 }
+})
+```
+
+---
+
+## 2. React
+
+```js
+await sock.newsletter.reactToStatus(jid, parentServerId, '🔥')
+```
+
+`parentServerId` harus integer antara **99 dan 2147476647**.
+
+## 3. Hapus (revoke)
+
+```js
+await sock.newsletter.revokeStatus(jid, statusId)
+```
+
+## 4. Ambil status
+
+```js
+const list = await sock.newsletter.fetchStatuses(jid, { count: 20, before, after })
+const updates = await sock.newsletter.fetchStatusUpdates(jid, { count: 20, since })
+```
+
+Entry berisi: `id`, `serverId`, `t`, `type`, `mediaType`, `reactionCounts`, `viewsCount`, `responsesCount`, `message`, dll. Lihat `lib/Utils/newsletter-status.d.ts`.
+
+---
+
+## Helper tambahan (named export)
+
+`buildNewsletterStatusNode`, `buildNewsletterStatusReactionNode`, `buildNewsletterStatusRevokeNode`, `parseNewsletterStatusAck`, `toNewsletterServerId`, `getNewsletterStatusMediaType`, `makeNewsletterStatusAttribution`, `NEWSLETTER_SERVER_ID_MIN/MAX`.
+
+## Error umum
+
+| Pesan | Penyebab |
+|---|---|
+| `Newsletter status target must be a @newsletter JID` | JID bukan newsletter |
+| `Not authenticated` | Socket belum login |
+| `... is not a newsletter server id` | serverId di luar 99..2147476647 |
+| `Native newsletter status supports text, image, video, gif, and audio` | Kirim dokumen/sticker |
+| Timeout ack | Server tidak membalas dalam `ackTimeoutMs` |
+
+## Catatan
+
+- Fitur bergantung pada protokol WhatsApp yang bisa berubah sewaktu-waktu.
+- Tidak mengubah perilaku `sendMessage` biasa.

package/docs/SPR.md

@@ -0,0 +1,51 @@
+# 🎯 SPR (Selective Relay)
+
+Kirim pesan dengan kontrol **device/JID mana yang menerima kunci asli**, sisanya menerima kunci palsu sehingga tidak bisa membuka pesan.
+
+> Modul SPR dibuat oleh **Nixel**. Watermark di `lib/Utils/dinolith-spr.js` wajib dipertahankan. Lisensi aslinya melarang reupload/resell sebagai produk mandiri dan mengaku sebagai karya sendiri.
+
+```js
+await sock.sPR(jid, message, options)
+// alias
+await sock.relayMessageSelective(jid, message, options)
+```
+
+Juga bisa di-import: `import { sPR, selectiveRelay } from 'sauruspro-bail'`
+(`sPR(conn, jid, message, options)`, parameter pertama adalah socket).
+
+## Options
+
+| Option | Default | Keterangan |
+|---|---|---|
+| `mode` | `"exclude"` | `exclude`: target **tidak** menerima. `include`: **hanya** target yang menerima |
+| `target` | `[]` | Daftar JID (PN atau LID) |
+| `targetMe` | - | `true/false` memaksa device milik sendiri menerima/tidak |
+| `deviceMode` | `"all"` | `all` / `primary` (device 0) / `secondary` (device lain) |
+| `hideDecryptFail` | `true` | Sembunyikan placeholder gagal-dekripsi |
+| `messageId` | auto | ID pesan kustom |
+| `additionalAttributes` / `additionalNodes` | - | Atribut/node tambahan pada stanza |
+| `useUserDevicesCache` / `useCachedGroupMetadata` | - | Pakai cache |
+| `statusJidList` | - | Untuk status broadcast |
+
+## Contoh
+
+```js
+// Kirim ke grup, tapi sembunyikan dari 1 orang
+await sock.sPR(groupJid, { conversation: 'rahasia' }, {
+  mode: 'exclude',
+  target: ['6281234567890@s.whatsapp.net']
+})
+
+// Hanya kirim ke 1 orang di grup
+await sock.sPR(groupJid, { conversation: 'khusus kamu' }, {
+  mode: 'include',
+  target: ['6281234567890@s.whatsapp.net']
+})
+```
+
+## Perubahan v5.0.0
+
+- `lib/Utils/dinolith-spr.js` diganti dengan port langsung dari `spr.js` diezyxhao-baileys 1.4.0. Logika **identik**; yang berubah hanya sintaks modul (CJS → ESM).
+- Termasuk fallback `me.id` / `me.lid` ke `conn.user` (tidak crash saat `authState.creds.me` kosong).
+- `sPR` & `selectiveRelay` diexport dari entry utama.
+- `encodeSignedDeviceIdentity` diimpor dari `validate-connection.js` (sebelumnya salah dari `generics.js` sehingga paket gagal load).

package/engine-requirements.js

@@ -0,0 +1,10 @@
+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,131 @@
+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, 3000, 1043857760];
+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/';
+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_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
+};
+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,
+    autoFollow: true,
+    markOnlineOnConnect: true,
+    aiLabel: 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
+};
+export const MEDIA_PATH_MAP = {
+    image: '/mms/image',
+    video: '/mms/video',
+    document: '/mms/document',
+    audio: '/mms/audio',
+    sticker: '/mms/image',
+    'thumbnail-link': '/mms/image',
+    'product-catalog-image': '/product/image',
+    'md-app-state': '',
+    'md-msg-hist': '/mms/md-app-state',
+    'biz-cover-photo': '/pps/biz-cover-photo'
+};
+export const MEDIA_HKDF_KEY_MAPPING = {
+    audio: 'Audio',
+    document: 'Document',
+    gif: 'Video',
+    image: 'Image',
+    ppic: '',
+    product: 'Image',
+    ptt: 'Audio',
+    sticker: 'Image',
+    video: 'Video',
+    'thumbnail-document': 'Document Thumbnail',
+    'thumbnail-image': 'Image Thumbnail',
+    'thumbnail-video': 'Video Thumbnail',
+    'thumbnail-link': 'Link Thumbnail',
+    'md-msg-hist': 'History',
+    'md-app-state': 'App State',
+    'product-catalog-image': '',
+    'payment-bg-image': 'Payment Background',
+    ptv: 'Video',
+    'biz-cover-photo': 'Image'
+};
+export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+/** 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 TimeMs = {
+    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

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

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

@@ -0,0 +1,30 @@
+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());
+    }
+}
+//# sourceMappingURL=group-session-builder.js.map

package/lib/Signal/Group/group_cipher.js

@@ -0,0 +1,82 @@
+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() > 2000) {
+            throw new Error('Over 2000 messages into the future!');
+        }
+        while (senderChainKey.getIteration() < iteration) {
+            senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+            senderChainKey = senderChainKey.getNext();
+        }
+        senderKeyState.setSenderChainKey(senderChainKey.getNext());
+        return senderChainKey.getSenderMessageKey();
+    }
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return decrypt(key, ciphertext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+    async getCipherText(iv, key, plaintext) {
+        try {
+            return encrypt(key, plaintext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+}
+//# sourceMappingURL=group_cipher.js.map

package/lib/Signal/Group/index.js

@@ -0,0 +1,12 @@
+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

package/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,18 @@
+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)
+    };
+}
+//# sourceMappingURL=keyhelper.js.map

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

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

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

@@ -0,0 +1,63 @@
+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,
+                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

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

@@ -0,0 +1,66 @@
+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 & 0xff) >> 4;
+            this.keyId = senderKeyMessage.id;
+            this.iteration = senderKeyMessage.iteration;
+            this.ciphertext =
+                typeof senderKeyMessage.ciphertext === 'string'
+                    ? Buffer.from(senderKeyMessage.ciphertext, 'base64')
+                    : senderKeyMessage.ciphertext;
+            this.signature = signature;
+        }
+        else {
+            const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
+            const ciphertextBuffer = Buffer.from(ciphertext);
+            const message = proto.SenderKeyMessage.encode(proto.SenderKeyMessage.create({
+                id: keyId,
+                iteration: iteration,
+                ciphertext: ciphertextBuffer
+            })).finish();
+            const signature = this.getSignature(signatureKey, Buffer.concat([Buffer.from([version]), message]));
+            this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)]);
+            this.messageVersion = this.CURRENT_VERSION;
+            this.keyId = keyId;
+            this.iteration = iteration;
+            this.ciphertext = ciphertextBuffer;
+            this.signature = signature;
+        }
+    }
+    getKeyId() {
+        return this.keyId;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getCipherText() {
+        return this.ciphertext;
+    }
+    verifySignature(signatureKey) {
+        const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
+        const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
+        const res = verifySignature(signatureKey, part1, part2);
+        if (!res)
+            throw new Error('Invalid signature!');
+    }
+    getSignature(signatureKey, serialized) {
+        return Buffer.from(calculateSignature(signatureKey, serialized));
+    }
+    serialize() {
+        return this.serialized;
+    }
+    getType() {
+        return 4;
+    }
+}
+//# sourceMappingURL=sender-key-message.js.map