@sixcore/baileys 1.0.0

package/lib/WAUSync/USyncUser.d.ts

@@ -0,0 +1,10 @@
+export declare class USyncUser {
+    id: string;
+    lid: string;
+    phone: string;
+    type: string;
+    withId(id: string): this;
+    withLid(lid: string): this;
+    withPhone(phone: string): this;
+    withType(type: string): this;
+}

package/lib/WAUSync/USyncUser.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USyncUser = void 0;
+class USyncUser {
+    withId(id) {
+        this.id = id;
+        return this;
+    }
+    withLid(lid) {
+        this.lid = lid;
+        return this;
+    }
+    withPhone(phone) {
+        this.phone = phone;
+        return this;
+    }
+    withType(type) {
+        this.type = type;
+        return this;
+    }
+    withPersonaId(personaId) {
+        this.personaId = personaId;
+        return this;
+    }
+}
+exports.USyncUser = USyncUser;

package/lib/WAUSync/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Protocols';
+export * from './USyncQuery';
+export * from './USyncUser';

package/lib/WAUSync/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Protocols"), exports);
+__exportStar(require("./USyncQuery"), exports);
+__exportStar(require("./USyncUser"), exports);

package/lib/index.js

@@ -0,0 +1,31 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeWASocket = void 0;
+const Socket_1 = __importDefault(require("./Socket"));
+exports.makeWASocket = Socket_1.default;
+__exportStar(require("../WAProto"), exports);
+__exportStar(require("./Utils"), exports);
+__exportStar(require("./Types"), exports);
+__exportStar(require("./Store"), exports);
+__exportStar(require("./Defaults"), exports);
+__exportStar(require("./WABinary"), exports);
+__exportStar(require("./WAM"), exports);
+__exportStar(require("./WAUSync"), exports);
+exports.default = Socket_1.default;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@sixcore/baileys",
+  "version": "1.0.0",
+  "description": "Baileys core adaptado para @sixcore/baileys",
+  "main": "lib/WAUSync/index.js",
+  "exports": {
+    ".": "./lib/WAUSync/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ytsixx/lena-baileys.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Ytsixx/lena-baileys/issues"
+  },
+  "homepage": "https://github.com/Ytsixx/lena-baileys",
+  "keywords": [
+    "baileys",
+    "whatsapp",
+    "core",
+    "lena"
+  ],
+  "author": "Sixx",
+  "license": "MIT",
+  "dependencies": {
+    "@cacheable/node-cache": "^2.0.1",
+    "@hapi/boom": "^10.0.1",
+    "async-lock": "^1.4.1",
+    "async-mutex": "^0.5.0",
+    "cache-manager": "^7.2.8",
+    "libsignal": "^2.0.1",
+    "libsignal-protocol": "^1.3.15",
+    "long": "^5.3.2",
+    "lru-cache": "^11.2.6",
+    "music-metadata": "^11.12.1",
+    "p-queue": "^9.1.0",
+    "pino": "^9.14.0",
+    "protobufjs": "^8.0.0",
+    "uuid": "^13.0.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "axios": "^1.13.5",
+    "node-cache": "^5.1.2",
+    "node-fetch": "^3.3.2",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "scripts": {
+    "test": "node test.js"
+  }
+}

package/src/Defaults/baileys-version.json

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

package/src/Defaults/index.ts

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

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

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

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

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

package/src/Signal/Group/keyhelper.ts

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

@@ -0,0 +1,34 @@
+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)
+	}
+}

package/src/Signal/Group/sender-key-distribution-message.ts

@@ -0,0 +1,95 @@
+import { proto } from '../../../WAProto/index.js'
+import { CiphertextMessage } from './ciphertext-message'
+
+interface SenderKeyDistributionMessageStructure {
+	id: number
+	iteration: number
+	chainKey: string | Uint8Array
+	signingKey: string | Uint8Array
+}
+
+export class SenderKeyDistributionMessage extends CiphertextMessage {
+	private readonly id: number
+	private readonly iteration: number
+	private readonly chainKey: Uint8Array
+	private readonly signatureKey: Uint8Array
+	private readonly serialized: Uint8Array
+
+	constructor(
+		id?: number | null,
+		iteration?: number | null,
+		chainKey?: Uint8Array | null,
+		signatureKey?: Uint8Array | null,
+		serialized?: Uint8Array | null
+	) {
+		super()
+
+		if (serialized) {
+			try {
+				const message = serialized.slice(1)
+				const distributionMessage = proto.SenderKeyDistributionMessage.decode(
+					message
+				).toJSON() as SenderKeyDistributionMessageStructure
+
+				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])
+		}
+	}
+
+	private intsToByteHighAndLow(highValue: number, lowValue: number): number {
+		return (((highValue << 4) | lowValue) & 0xff) % 256
+	}
+
+	public serialize(): Uint8Array {
+		return this.serialized
+	}
+
+	public getType(): number {
+		return this.SENDERKEY_DISTRIBUTION_TYPE
+	}
+
+	public getIteration(): number {
+		return this.iteration
+	}
+
+	public getChainKey(): Uint8Array {
+		return this.chainKey
+	}
+
+	public getSignatureKey(): Uint8Array {
+		return this.signatureKey
+	}
+
+	public getId(): number {
+		return this.id
+	}
+}