@sixcore/baileys 1.0.0 → 1.0.1

package/WASignalGroup/sender_key_state.js

@@ -1,129 +0,0 @@
-const SenderChainKey = require('./sender_chain_key');
-const SenderMessageKey = require('./sender_message_key');
-
-const protobufs = require('./protobufs');
-
-class SenderKeyState {
-    MAX_MESSAGE_KEYS = 2000;
-
-    constructor(
-        id = null,
-        iteration = null,
-        chainKey = null,
-        signatureKeyPair = null,
-        signatureKeyPublic = null,
-        signatureKeyPrivate = null,
-        senderKeyStateStructure = null
-    ) {
-        if (senderKeyStateStructure) {
-            this.senderKeyStateStructure = senderKeyStateStructure;
-        } else {
-            if (signatureKeyPair) {
-                signatureKeyPublic = signatureKeyPair.public;
-                signatureKeyPrivate = signatureKeyPair.private;
-            }
-
-            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
-            this.senderKeyStateStructure = protobufs.SenderKeyStateStructure.create();
-            const senderChainKeyStructure = protobufs.SenderChainKey.create();
-            senderChainKeyStructure.iteration = iteration;
-            senderChainKeyStructure.seed = chainKey;
-            this.senderKeyStateStructure.senderChainKey = senderChainKeyStructure;
-
-            const signingKeyStructure = protobufs.SenderSigningKey.create();
-            signingKeyStructure.public =
-                typeof signatureKeyPublic === 'string' ?
-                Buffer.from(signatureKeyPublic, 'base64') :
-                signatureKeyPublic;
-            if (signatureKeyPrivate) {
-                signingKeyStructure.private =
-                    typeof signatureKeyPrivate === 'string' ?
-                    Buffer.from(signatureKeyPrivate, 'base64') :
-                    signatureKeyPrivate;
-            }
-            this.senderKeyStateStructure.senderKeyId = id;
-            this.senderChainKey = senderChainKeyStructure;
-            this.senderKeyStateStructure.senderSigningKey = signingKeyStructure;
-        }
-        this.senderKeyStateStructure.senderMessageKeys =
-            this.senderKeyStateStructure.senderMessageKeys || [];
-    }
-
-    SenderKeyState(senderKeyStateStructure) {
-        this.senderKeyStateStructure = senderKeyStateStructure;
-    }
-
-    getKeyId() {
-        return this.senderKeyStateStructure.senderKeyId;
-    }
-
-    getSenderChainKey() {
-        return new SenderChainKey(
-            this.senderKeyStateStructure.senderChainKey.iteration,
-            this.senderKeyStateStructure.senderChainKey.seed
-        );
-    }
-
-    setSenderChainKey(chainKey) {
-        const senderChainKeyStructure = protobufs.SenderChainKey.create({
-            iteration: chainKey.getIteration(),
-            seed: chainKey.getSeed(),
-        });
-        this.senderKeyStateStructure.senderChainKey = senderChainKeyStructure;
-    }
-
-    getSigningKeyPublic() {
-        return typeof this.senderKeyStateStructure.senderSigningKey.public === 'string' ?
-            Buffer.from(this.senderKeyStateStructure.senderSigningKey.public, 'base64') :
-            this.senderKeyStateStructure.senderSigningKey.public;
-    }
-
-    getSigningKeyPrivate() {
-        return typeof this.senderKeyStateStructure.senderSigningKey.private === 'string' ?
-            Buffer.from(this.senderKeyStateStructure.senderSigningKey.private, 'base64') :
-            this.senderKeyStateStructure.senderSigningKey.private;
-    }
-
-    hasSenderMessageKey(iteration) {
-        const list = this.senderKeyStateStructure.senderMessageKeys;
-        for (let o = 0; o < list.length; o++) {
-            const senderMessageKey = list[o];
-            if (senderMessageKey.iteration === iteration) return true;
-        }
-        return false;
-    }
-
-    addSenderMessageKey(senderMessageKey) {
-        const senderMessageKeyStructure = protobufs.SenderKeyStateStructure.create({
-            iteration: senderMessageKey.getIteration(),
-            seed: senderMessageKey.getSeed(),
-        });
-        this.senderKeyStateStructure.senderMessageKeys.push(senderMessageKeyStructure);
-
-        if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
-            this.senderKeyStateStructure.senderMessageKeys.shift();
-        }
-    }
-
-    removeSenderMessageKey(iteration) {
-        let result = null;
-
-        this.senderKeyStateStructure.senderMessageKeys = this.senderKeyStateStructure.senderMessageKeys.filter(
-            senderMessageKey => {
-                if (senderMessageKey.iteration === iteration) result = senderMessageKey;
-                return senderMessageKey.iteration !== iteration;
-            }
-        );
-
-        if (result != null) {
-            return new SenderMessageKey(result.iteration, result.seed);
-        }
-        return null;
-    }
-
-    getStructure() {
-        return this.senderKeyStateStructure;
-    }
-}
-
-module.exports = SenderKeyState;

package/lib/Utils/use-single-file-auth-state.d.ts

@@ -1,12 +0,0 @@
-import type { Logger } from 'pino';
-import type { AuthenticationState } from '../Types';
-/**
- * @deprecated use multi file auth state instead please
- * stores the full authentication state in a single JSON file
- *
- * DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
- * */
-export declare const useSingleFileAuthState: (filename: string, logger?: Logger) => {
-    state: AuthenticationState;
-    saveState: () => void;
-};

package/lib/Utils/use-single-file-auth-state.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSingleFileAuthState = void 0;
-const WAProto_1 = require("../../WAProto");
-const auth_utils_1 = require("./auth-utils");
-const generics_1 = require("./generics");
-// useless key map only there to maintain backwards compatibility
-// do not use in your own systems please
-const KEY_MAP = {
-    'pre-key': 'preKeys',
-    'session': 'sessions',
-    'sender-key': 'senderKeys',
-    'app-state-sync-key': 'appStateSyncKeys',
-    'app-state-sync-version': 'appStateVersions',
-    'sender-key-memory': 'senderKeyMemory'
-};
-/**
- * @deprecated use multi file auth state instead please
- * stores the full authentication state in a single JSON file
- *
- * DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
- * */
-const useSingleFileAuthState = (filename, logger) => {
-    // require fs here so that in case "fs" is not available -- the app does not crash
-    const { readFileSync, writeFileSync, existsSync } = require('fs');
-    let creds;
-    let keys = {};
-    // save the authentication state to a file
-    const saveState = () => {
-        logger && logger.trace('saving auth state');
-        writeFileSync(filename, 
-        // BufferJSON replacer utility saves buffers nicely
-        JSON.stringify({ creds, keys }, generics_1.BufferJSON.replacer, 2));
-    };
-    if (existsSync(filename)) {
-        const result = JSON.parse(readFileSync(filename, { encoding: 'utf-8' }), generics_1.BufferJSON.reviver);
-        creds = result.creds;
-        keys = result.keys;
-    }
-    else {
-        creds = (0, auth_utils_1.initAuthCreds)();
-        keys = {};
-    }
-    return {
-        state: {
-            creds,
-            keys: {
-                get: (type, ids) => {
-                    const key = KEY_MAP[type];
-                    return ids.reduce((dict, id) => {
-                        var _a;
-                        let value = (_a = keys[key]) === null || _a === void 0 ? void 0 : _a[id];
-                        if (value) {
-                            if (type === 'app-state-sync-key') {
-                                value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
-                            }
-                            dict[id] = value;
-                        }
-                        return dict;
-                    }, {});
-                },
-                set: (data) => {
-                    for (const _key in data) {
-                        const key = KEY_MAP[_key];
-                        keys[key] = keys[key] || {};
-                        Object.assign(keys[key], data[_key]);
-                    }
-                    saveState();
-                }
-            }
-        },
-        saveState
-    };
-};
-exports.useSingleFileAuthState = useSingleFileAuthState;

package/src/Defaults/baileys-version.json

@@ -1,3 +0,0 @@
-{
-	"version": [2, 3000, 1027934701]
-}

package/src/Defaults/index.ts

@@ -1,133 +0,0 @@
-import { proto } from '../../WAProto/index.js'
-import { makeLibSignalRepository } from '../Signal/libsignal'
-import type { AuthenticationState, SocketConfig, WAVersion } from '../Types'
-import { Browsers } from '../Utils/browser-utils'
-import logger from '../Utils/logger'
-
-const version = [2, 3000, 1027934701]
-
-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
-
-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
-
-// TODO: Add WA root CA
-export const WA_CERT_DETAILS = {
-	SERIAL: 0
-}
-
-export const PROCESSABLE_HISTORY_TYPES = [
-	proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
-	proto.HistorySync.HistorySyncType.PUSH_NAME,
-	proto.HistorySync.HistorySyncType.RECENT,
-	proto.HistorySync.HistorySyncType.FULL,
-	proto.HistorySync.HistorySyncType.ON_DEMAND,
-	proto.HistorySync.HistorySyncType.NON_BLOCKING_DATA,
-	proto.HistorySync.HistorySyncType.INITIAL_STATUS_V3
-]
-
-export const DEFAULT_CONNECTION_CONFIG: SocketConfig = {
-	version: version as WAVersion,
-	browser: Browsers.macOS('Chrome'),
-	waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
-	connectTimeoutMs: 20_000,
-	keepAliveIntervalMs: 30_000,
-	logger: logger.child({ class: 'baileys' }),
-	emitOwnEvents: true,
-	defaultQueryTimeoutMs: 60_000,
-	customUploadHosts: [],
-	retryRequestDelayMs: 250,
-	maxMsgRetryCount: 5,
-	fireInitQueries: true,
-	auth: undefined as unknown as AuthenticationState,
-	markOnlineOnConnect: true,
-	syncFullHistory: true,
-	patchMessageBeforeSending: msg => msg,
-	shouldSyncHistoryMessage: () => true,
-	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: { [T in MediaType]?: string } = {
-	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 type MediaType = keyof typeof MEDIA_HKDF_KEY_MAPPING
-
-export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP) as MediaType[]
-
-export const MIN_PREKEY_COUNT = 5
-
-export const INITIAL_PREKEY_COUNT = 812
-
-export const UPLOAD_TIMEOUT = 30000 // 30 seconds
-export const MIN_UPLOAD_INTERVAL = 5000 // 5 seconds minimum between uploads
-
-export const DEFAULT_CACHE_TTLS = {
-	SIGNAL_STORE: 5 * 60, // 5 minutes
-	MSG_RETRY: 60 * 60, // 1 hour
-	CALL_OFFER: 5 * 60, // 5 minutes
-	USER_DEVICES: 5 * 60 // 5 minutes
-}

package/src/Signal/Group/ciphertext-message.ts

@@ -1,9 +0,0 @@
-export class CiphertextMessage {
-	readonly UNSUPPORTED_VERSION: number = 1
-	readonly CURRENT_VERSION: number = 3
-	readonly WHISPER_TYPE: number = 2
-	readonly PREKEY_TYPE: number = 3
-	readonly SENDERKEY_TYPE: number = 4
-	readonly SENDERKEY_DISTRIBUTION_TYPE: number = 5
-	readonly ENCRYPTED_MESSAGE_OVERHEAD: number = 53
-}

package/src/Signal/Group/group-session-builder.ts

@@ -1,56 +0,0 @@
-import * as keyhelper from './keyhelper'
-import { SenderKeyDistributionMessage } from './sender-key-distribution-message'
-import { SenderKeyName } from './sender-key-name'
-import { SenderKeyRecord } from './sender-key-record'
-
-interface SenderKeyStore {
-	loadSenderKey(senderKeyName: SenderKeyName): Promise<SenderKeyRecord>
-	storeSenderKey(senderKeyName: SenderKeyName, record: SenderKeyRecord): Promise<void>
-}
-
-export class GroupSessionBuilder {
-	private readonly senderKeyStore: SenderKeyStore
-
-	constructor(senderKeyStore: SenderKeyStore) {
-		this.senderKeyStore = senderKeyStore
-	}
-
-	public async process(
-		senderKeyName: SenderKeyName,
-		senderKeyDistributionMessage: SenderKeyDistributionMessage
-	): Promise<void> {
-		const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName)
-		senderKeyRecord.addSenderKeyState(
-			senderKeyDistributionMessage.getId(),
-			senderKeyDistributionMessage.getIteration(),
-			senderKeyDistributionMessage.getChainKey(),
-			senderKeyDistributionMessage.getSignatureKey()
-		)
-		await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord)
-	}
-
-	public async create(senderKeyName: SenderKeyName): Promise<SenderKeyDistributionMessage> {
-		const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName)
-
-		if (senderKeyRecord.isEmpty()) {
-			const keyId = keyhelper.generateSenderKeyId()
-			const senderKey = keyhelper.generateSenderKey()
-			const signingKey = keyhelper.generateSenderSigningKey()
-
-			senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey)
-			await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord)
-		}
-
-		const state = senderKeyRecord.getSenderKeyState()
-		if (!state) {
-			throw new Error('No session state available')
-		}
-
-		return new SenderKeyDistributionMessage(
-			state.getKeyId(),
-			state.getSenderChainKey().getIteration(),
-			state.getSenderChainKey().getSeed(),
-			state.getSigningKeyPublic()
-		)
-	}
-}

package/src/Signal/Group/group_cipher.ts

@@ -1,117 +0,0 @@
-import { decrypt, encrypt } from 'libsignal/src/crypto'
-import { SenderKeyMessage } from './sender-key-message'
-import { SenderKeyName } from './sender-key-name'
-import { SenderKeyRecord } from './sender-key-record'
-import { SenderKeyState } from './sender-key-state'
-
-export interface SenderKeyStore {
-	loadSenderKey(senderKeyName: SenderKeyName): Promise<SenderKeyRecord>
-
-	storeSenderKey(senderKeyName: SenderKeyName, record: SenderKeyRecord): Promise<void>
-}
-
-export class GroupCipher {
-	private readonly senderKeyStore: SenderKeyStore
-	private readonly senderKeyName: SenderKeyName
-
-	constructor(senderKeyStore: SenderKeyStore, senderKeyName: SenderKeyName) {
-		this.senderKeyStore = senderKeyStore
-		this.senderKeyName = senderKeyName
-	}
-
-	public async encrypt(paddedPlaintext: Uint8Array): Promise<Uint8Array> {
-		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()
-	}
-
-	public async decrypt(senderKeyMessageBytes: Uint8Array): Promise<Uint8Array> {
-		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
-	}
-
-	private getSenderKey(senderKeyState: SenderKeyState, iteration: number) {
-		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()
-	}
-
-	private async getPlainText(iv: Uint8Array, key: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array> {
-		try {
-			return decrypt(key, ciphertext, iv)
-		} catch (e) {
-			throw new Error('InvalidMessageException')
-		}
-	}
-
-	private async getCipherText(iv: Uint8Array, key: Uint8Array, plaintext: Uint8Array): Promise<Buffer> {
-		try {
-			return encrypt(key, plaintext, iv)
-		} catch (e) {
-			throw new Error('InvalidMessageException')
-		}
-	}
-}

package/src/Signal/Group/index.ts

@@ -1,11 +0,0 @@
-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/src/Signal/Group/keyhelper.ts

@@ -1,28 +0,0 @@
-import * as nodeCrypto from 'crypto'
-import { generateKeyPair } from 'libsignal/src/curve'
-
-type KeyPairType = ReturnType<typeof generateKeyPair>
-
-export function generateSenderKey(): Buffer {
-	return nodeCrypto.randomBytes(32)
-}
-
-export function generateSenderKeyId(): number {
-	return nodeCrypto.randomInt(2147483647)
-}
-
-export interface SigningKeyPair {
-	public: Buffer
-	private: Buffer
-}
-
-export function generateSenderSigningKey(key?: KeyPairType): SigningKeyPair {
-	if (!key) {
-		key = generateKeyPair()
-	}
-
-	return {
-		public: Buffer.from(key.pubKey),
-		private: Buffer.from(key.privKey)
-	}
-}

package/src/Signal/Group/sender-chain-key.ts

@@ -1,34 +0,0 @@
-import { calculateMAC } from 'libsignal/src/crypto'
-import { SenderMessageKey } from './sender-message-key'
-
-export class SenderChainKey {
-	private readonly MESSAGE_KEY_SEED: Uint8Array = Buffer.from([0x01])
-	private readonly CHAIN_KEY_SEED: Uint8Array = Buffer.from([0x02])
-	private readonly iteration: number
-	private readonly chainKey: Buffer
-
-	constructor(iteration: number, chainKey: Uint8Array | Buffer) {
-		this.iteration = iteration
-		this.chainKey = Buffer.from(chainKey)
-	}
-
-	public getIteration(): number {
-		return this.iteration
-	}
-
-	public getSenderMessageKey(): SenderMessageKey {
-		return new SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey))
-	}
-
-	public getNext(): SenderChainKey {
-		return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey))
-	}
-
-	public getSeed(): Uint8Array {
-		return this.chainKey
-	}
-
-	private getDerivative(seed: Uint8Array, key: Buffer): Uint8Array {
-		return calculateMAC(key, seed)
-	}
-}