@sixcore/baileys 1.0.0

package/src/WAM/encode.ts

@@ -0,0 +1,169 @@
+import { BinaryInfo } from './BinaryInfo'
+import {
+	FLAG_BYTE,
+	FLAG_EVENT,
+	FLAG_EXTENDED,
+	FLAG_FIELD,
+	FLAG_GLOBAL,
+	type Value,
+	WEB_EVENTS,
+	WEB_GLOBALS
+} from './constants'
+
+const getHeaderBitLength = (key: number) => (key < 256 ? 2 : 3)
+
+export const encodeWAM = (binaryInfo: BinaryInfo) => {
+	binaryInfo.buffer = []
+
+	encodeWAMHeader(binaryInfo)
+	encodeEvents(binaryInfo)
+
+	const totalSize = binaryInfo.buffer.map(a => a.length).reduce((a, b) => a + b)
+	const buffer = Buffer.alloc(totalSize)
+	let offset = 0
+	for (const buffer_ of binaryInfo.buffer) {
+		buffer_.copy(buffer, offset)
+		offset += buffer_.length
+	}
+
+	return buffer
+}
+
+function encodeWAMHeader(binaryInfo: BinaryInfo) {
+	const headerBuffer = Buffer.alloc(8) // starting buffer
+	headerBuffer.write('WAM', 0, 'utf8')
+	headerBuffer.writeUInt8(binaryInfo.protocolVersion, 3)
+	headerBuffer.writeUInt8(1, 4) //random flag
+	headerBuffer.writeUInt16BE(binaryInfo.sequence, 5)
+	headerBuffer.writeUInt8(0, 7) // regular channel
+
+	binaryInfo.buffer.push(headerBuffer)
+}
+
+function encodeGlobalAttributes(binaryInfo: BinaryInfo, globals: { [key: string]: Value }) {
+	for (const [key, _value] of Object.entries(globals)) {
+		const id = WEB_GLOBALS.find(a => a?.name === key)!.id
+		let value = _value
+		if (typeof value === 'boolean') {
+			value = value ? 1 : 0
+		}
+
+		binaryInfo.buffer.push(serializeData(id, value, FLAG_GLOBAL))
+	}
+}
+
+function encodeEvents(binaryInfo: BinaryInfo) {
+	for (const [name, { props, globals }] of binaryInfo.events.map(a => Object.entries(a)[0]!)) {
+		encodeGlobalAttributes(binaryInfo, globals)
+		const event = WEB_EVENTS.find(a => a.name === name)!
+
+		const props_ = Object.entries(props)
+
+		let extended = false
+
+		for (const [, value] of props_) {
+			extended ||= value !== null
+		}
+
+		const eventFlag = extended ? FLAG_EVENT : FLAG_EVENT | FLAG_EXTENDED
+		binaryInfo.buffer.push(serializeData(event.id, -event.weight, eventFlag))
+
+		for (let i = 0; i < props_.length; i++) {
+			const [key, _value] = props_[i]!
+			const id = event.props[key]?.[0]
+			extended = i < props_.length - 1
+			let value = _value
+			if (typeof value === 'boolean') {
+				value = value ? 1 : 0
+			}
+
+			const fieldFlag = extended ? FLAG_EVENT : FLAG_FIELD | FLAG_EXTENDED
+			binaryInfo.buffer.push(serializeData(id!, value, fieldFlag))
+		}
+	}
+}
+
+function serializeData(key: number, value: Value, flag: number): Buffer {
+	const bufferLength = getHeaderBitLength(key)
+	let buffer: Buffer
+	let offset = 0
+	if (value === null) {
+		if (flag === FLAG_GLOBAL) {
+			buffer = Buffer.alloc(bufferLength)
+			offset = serializeHeader(buffer, offset, key, flag)
+			return buffer
+		}
+	} else if (typeof value === 'number' && Number.isInteger(value)) {
+		// is number
+		if (value === 0 || value === 1) {
+			buffer = Buffer.alloc(bufferLength)
+			offset = serializeHeader(buffer, offset, key, flag | ((value + 1) << 4))
+			return buffer
+		} else if (-128 <= value && value < 128) {
+			buffer = Buffer.alloc(bufferLength + 1)
+			offset = serializeHeader(buffer, offset, key, flag | (3 << 4))
+			buffer.writeInt8(value, offset)
+			return buffer
+		} else if (-32768 <= value && value < 32768) {
+			buffer = Buffer.alloc(bufferLength + 2)
+			offset = serializeHeader(buffer, offset, key, flag | (4 << 4))
+			buffer.writeInt16LE(value, offset)
+			return buffer
+		} else if (-2147483648 <= value && value < 2147483648) {
+			buffer = Buffer.alloc(bufferLength + 4)
+			offset = serializeHeader(buffer, offset, key, flag | (5 << 4))
+			buffer.writeInt32LE(value, offset)
+			return buffer
+		} else {
+			buffer = Buffer.alloc(bufferLength + 8)
+			offset = serializeHeader(buffer, offset, key, flag | (7 << 4))
+			buffer.writeDoubleLE(value, offset)
+			return buffer
+		}
+	} else if (typeof value === 'number') {
+		// is float
+		buffer = Buffer.alloc(bufferLength + 8)
+		offset = serializeHeader(buffer, offset, key, flag | (7 << 4))
+		buffer.writeDoubleLE(value, offset)
+		return buffer
+	} else if (typeof value === 'string') {
+		// is string
+		const utf8Bytes = Buffer.byteLength(value, 'utf8')
+		if (utf8Bytes < 256) {
+			buffer = Buffer.alloc(bufferLength + 1 + utf8Bytes)
+			offset = serializeHeader(buffer, offset, key, flag | (8 << 4))
+			buffer.writeUint8(utf8Bytes, offset++)
+		} else if (utf8Bytes < 65536) {
+			buffer = Buffer.alloc(bufferLength + 2 + utf8Bytes)
+			offset = serializeHeader(buffer, offset, key, flag | (9 << 4))
+			buffer.writeUInt16LE(utf8Bytes, offset)
+			offset += 2
+		} else {
+			buffer = Buffer.alloc(bufferLength + 4 + utf8Bytes)
+			offset = serializeHeader(buffer, offset, key, flag | (10 << 4))
+			buffer.writeUInt32LE(utf8Bytes, offset)
+			offset += 4
+		}
+
+		buffer.write(value, offset, 'utf8')
+		return buffer
+	}
+
+	throw 'missing'
+}
+
+function serializeHeader(buffer: Buffer, offset: number, key: number, flag: number) {
+	if (key < 256) {
+		buffer.writeUInt8(flag, offset)
+		offset += 1
+		buffer.writeUInt8(key, offset)
+		offset += 1
+	} else {
+		buffer.writeUInt8(flag | FLAG_BYTE, offset)
+		offset += 1
+		buffer.writeUInt16LE(key, offset)
+		offset += 2
+	}
+
+	return offset
+}

package/src/WAM/index.ts

@@ -0,0 +1,3 @@
+export * from './constants'
+export * from './encode'
+export * from './BinaryInfo'

package/src/WAUSync/Protocols/USyncContactProtocol.ts

@@ -0,0 +1,32 @@
+import type { USyncQueryProtocol } from '../../Types/USync'
+import { assertNodeErrorFree, type BinaryNode } from '../../WABinary'
+import { USyncUser } from '../USyncUser'
+
+export class USyncContactProtocol implements USyncQueryProtocol {
+	name = 'contact'
+
+	getQueryElement(): BinaryNode {
+		return {
+			tag: 'contact',
+			attrs: {}
+		}
+	}
+
+	getUserElement(user: USyncUser): BinaryNode {
+		//TODO: Implement type / username fields (not yet supported)
+		return {
+			tag: 'contact',
+			attrs: {},
+			content: user.phone
+		}
+	}
+
+	parser(node: BinaryNode): boolean {
+		if (node.tag === 'contact') {
+			assertNodeErrorFree(node)
+			return node?.attrs?.type === 'in'
+		}
+
+		return false
+	}
+}

package/src/WAUSync/Protocols/USyncDeviceProtocol.ts

@@ -0,0 +1,78 @@
+import type { USyncQueryProtocol } from '../../Types/USync'
+import { assertNodeErrorFree, type BinaryNode, getBinaryNodeChild } from '../../WABinary'
+//import { USyncUser } from '../USyncUser'
+
+export type KeyIndexData = {
+	timestamp: number
+	signedKeyIndex?: Uint8Array
+	expectedTimestamp?: number
+}
+
+export type DeviceListData = {
+	id: number
+	keyIndex?: number
+	isHosted?: boolean
+}
+
+export type ParsedDeviceInfo = {
+	deviceList?: DeviceListData[]
+	keyIndex?: KeyIndexData
+}
+
+export class USyncDeviceProtocol implements USyncQueryProtocol {
+	name = 'devices'
+
+	getQueryElement(): BinaryNode {
+		return {
+			tag: 'devices',
+			attrs: {
+				version: '2'
+			}
+		}
+	}
+
+	getUserElement(/* user: USyncUser */): BinaryNode | null {
+		//TODO: Implement device phashing, ts and expectedTs
+		//TODO: if all are not present, return null <- current behavior
+		//TODO: otherwise return a node w tag 'devices' w those as attrs
+		return null
+	}
+
+	parser(node: BinaryNode): ParsedDeviceInfo {
+		const deviceList: DeviceListData[] = []
+		let keyIndex: KeyIndexData | undefined = undefined
+
+		if (node.tag === 'devices') {
+			assertNodeErrorFree(node)
+			const deviceListNode = getBinaryNodeChild(node, 'device-list')
+			const keyIndexNode = getBinaryNodeChild(node, 'key-index-list')
+
+			if (Array.isArray(deviceListNode?.content)) {
+				for (const { tag, attrs } of deviceListNode.content) {
+					const id = +attrs.id!
+					const keyIndex = +attrs['key-index']!
+					if (tag === 'device') {
+						deviceList.push({
+							id,
+							keyIndex,
+							isHosted: !!(attrs['is_hosted'] && attrs['is_hosted'] === 'true')
+						})
+					}
+				}
+			}
+
+			if (keyIndexNode?.tag === 'key-index-list') {
+				keyIndex = {
+					timestamp: +keyIndexNode.attrs['ts']!,
+					signedKeyIndex: keyIndexNode?.content as Uint8Array,
+					expectedTimestamp: keyIndexNode.attrs['expected_ts'] ? +keyIndexNode.attrs['expected_ts'] : undefined
+				}
+			}
+		}
+
+		return {
+			deviceList,
+			keyIndex
+		}
+	}
+}

package/src/WAUSync/Protocols/USyncDisappearingModeProtocol.ts

@@ -0,0 +1,35 @@
+import type { USyncQueryProtocol } from '../../Types/USync'
+import { assertNodeErrorFree, type BinaryNode } from '../../WABinary'
+
+export type DisappearingModeData = {
+	duration: number
+	setAt?: Date
+}
+
+export class USyncDisappearingModeProtocol implements USyncQueryProtocol {
+	name = 'disappearing_mode'
+
+	getQueryElement(): BinaryNode {
+		return {
+			tag: 'disappearing_mode',
+			attrs: {}
+		}
+	}
+
+	getUserElement(): null {
+		return null
+	}
+
+	parser(node: BinaryNode): DisappearingModeData | undefined {
+		if (node.tag === 'disappearing_mode') {
+			assertNodeErrorFree(node)
+			const duration: number = +node?.attrs.duration!
+			const setAt = new Date(+(node?.attrs.t || 0) * 1000)
+
+			return {
+				duration,
+				setAt
+			}
+		}
+	}
+}

package/src/WAUSync/Protocols/USyncStatusProtocol.ts

@@ -0,0 +1,44 @@
+import type { USyncQueryProtocol } from '../../Types/USync'
+import { assertNodeErrorFree, type BinaryNode } from '../../WABinary'
+
+export type StatusData = {
+	status?: string | null
+	setAt?: Date
+}
+
+export class USyncStatusProtocol implements USyncQueryProtocol {
+	name = 'status'
+
+	getQueryElement(): BinaryNode {
+		return {
+			tag: 'status',
+			attrs: {}
+		}
+	}
+
+	getUserElement(): null {
+		return null
+	}
+
+	parser(node: BinaryNode): StatusData | undefined {
+		if (node.tag === 'status') {
+			assertNodeErrorFree(node)
+			let status: string | null = node?.content?.toString() ?? null
+			const setAt = new Date(+(node?.attrs.t || 0) * 1000)
+			if (!status) {
+				if (node.attrs?.code && +node.attrs.code === 401) {
+					status = ''
+				} else {
+					status = null
+				}
+			} else if (typeof status === 'string' && status.length === 0) {
+				status = null
+			}
+
+			return {
+				status,
+				setAt
+			}
+		}
+	}
+}

package/src/WAUSync/Protocols/UsyncBotProfileProtocol.ts

@@ -0,0 +1,76 @@
+import type { USyncQueryProtocol } from '../../Types/USync'
+import { type BinaryNode, getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString } from '../../WABinary'
+import { USyncUser } from '../USyncUser'
+
+export type BotProfileCommand = {
+	name: string
+	description: string
+}
+
+export type BotProfileInfo = {
+	jid: string
+	name: string
+	attributes: string
+	description: string
+	category: string
+	isDefault: boolean
+	prompts: string[]
+	personaId: string
+	commands: BotProfileCommand[]
+	commandsDescription: string
+}
+
+export class USyncBotProfileProtocol implements USyncQueryProtocol {
+	name = 'bot'
+
+	getQueryElement(): BinaryNode {
+		return {
+			tag: 'bot',
+			attrs: {},
+			content: [{ tag: 'profile', attrs: { v: '1' } }]
+		}
+	}
+
+	getUserElement(user: USyncUser): BinaryNode {
+		return {
+			tag: 'bot',
+			attrs: {},
+			content: [{ tag: 'profile', attrs: { persona_id: user.personaId! } }]
+		}
+	}
+
+	parser(node: BinaryNode): BotProfileInfo {
+		const botNode = getBinaryNodeChild(node, 'bot')
+		const profile = getBinaryNodeChild(botNode, 'profile')
+
+		const commandsNode = getBinaryNodeChild(profile, 'commands')
+		const promptsNode = getBinaryNodeChild(profile, 'prompts')
+
+		const commands: BotProfileCommand[] = []
+		const prompts: string[] = []
+
+		for (const command of getBinaryNodeChildren(commandsNode, 'command')) {
+			commands.push({
+				name: getBinaryNodeChildString(command, 'name')!,
+				description: getBinaryNodeChildString(command, 'description')!
+			})
+		}
+
+		for (const prompt of getBinaryNodeChildren(promptsNode, 'prompt')) {
+			prompts.push(`${getBinaryNodeChildString(prompt, 'emoji')!} ${getBinaryNodeChildString(prompt, 'text')!}`)
+		}
+
+		return {
+			isDefault: !!getBinaryNodeChild(profile, 'default'),
+			jid: node.attrs.jid!,
+			name: getBinaryNodeChildString(profile, 'name')!,
+			attributes: getBinaryNodeChildString(profile, 'attributes')!,
+			description: getBinaryNodeChildString(profile, 'description')!,
+			category: getBinaryNodeChildString(profile, 'category')!,
+			personaId: profile!.attrs['persona_id']!,
+			commandsDescription: getBinaryNodeChildString(commandsNode, 'description')!,
+			commands,
+			prompts
+		}
+	}
+}

package/src/WAUSync/Protocols/UsyncLIDProtocol.ts

@@ -0,0 +1,33 @@
+import type { USyncQueryProtocol } from '../../Types/USync'
+import type { BinaryNode } from '../../WABinary'
+import type { USyncUser } from '../USyncUser'
+
+export class USyncLIDProtocol implements USyncQueryProtocol {
+	name = 'lid'
+
+	getQueryElement(): BinaryNode {
+		return {
+			tag: 'lid',
+			attrs: {}
+		}
+	}
+
+	getUserElement(user: USyncUser): BinaryNode | null {
+		if (user.lid) {
+			return {
+				tag: 'lid',
+				attrs: { jid: user.lid }
+			}
+		} else {
+			return null
+		}
+	}
+
+	parser(node: BinaryNode): string | null {
+		if (node.tag === 'lid') {
+			return node.attrs.val!
+		}
+
+		return null
+	}
+}

package/src/WAUSync/Protocols/index.ts

@@ -0,0 +1,4 @@
+export * from './USyncDeviceProtocol'
+export * from './USyncContactProtocol'
+export * from './USyncStatusProtocol'
+export * from './USyncDisappearingModeProtocol'

package/src/WAUSync/USyncQuery.ts

@@ -0,0 +1,133 @@
+import type { USyncQueryProtocol } from '../Types/USync'
+import { type BinaryNode, getBinaryNodeChild } from '../WABinary'
+import { USyncBotProfileProtocol } from './Protocols/UsyncBotProfileProtocol'
+import { USyncLIDProtocol } from './Protocols/UsyncLIDProtocol'
+import {
+	USyncContactProtocol,
+	USyncDeviceProtocol,
+	USyncDisappearingModeProtocol,
+	USyncStatusProtocol
+} from './Protocols'
+import { USyncUser } from './USyncUser'
+
+export type USyncQueryResultList = { [protocol: string]: unknown; id: string }
+
+export type USyncQueryResult = {
+	list: USyncQueryResultList[]
+	sideList: USyncQueryResultList[]
+}
+
+export class USyncQuery {
+	protocols: USyncQueryProtocol[]
+	users: USyncUser[]
+	context: string
+	mode: string
+
+	constructor() {
+		this.protocols = []
+		this.users = []
+		this.context = 'interactive'
+		this.mode = 'query'
+	}
+
+	withMode(mode: string) {
+		this.mode = mode
+		return this
+	}
+
+	withContext(context: string) {
+		this.context = context
+		return this
+	}
+
+	withUser(user: USyncUser) {
+		this.users.push(user)
+		return this
+	}
+
+	parseUSyncQueryResult(result: BinaryNode | undefined): USyncQueryResult | undefined {
+		if (!result || result.attrs.type !== 'result') {
+			return
+		}
+
+		const protocolMap = Object.fromEntries(
+			this.protocols.map(protocol => {
+				return [protocol.name, protocol.parser]
+			})
+		)
+
+		const queryResult: USyncQueryResult = {
+			// TODO: implement errors etc.
+			list: [],
+			sideList: []
+		}
+
+		const usyncNode = getBinaryNodeChild(result, 'usync')
+
+		//TODO: implement error backoff, refresh etc.
+		//TODO: see if there are any errors in the result node
+		//const resultNode = getBinaryNodeChild(usyncNode, 'result')
+
+		const listNode = usyncNode ? getBinaryNodeChild(usyncNode, 'list') : undefined
+
+		if (listNode?.content && Array.isArray(listNode.content)) {
+			queryResult.list = listNode.content.reduce((acc: USyncQueryResultList[], node) => {
+				const id = node?.attrs.jid
+				if (id) {
+					const data = Array.isArray(node?.content)
+						? Object.fromEntries(
+								node.content
+									.map(content => {
+										const protocol = content.tag
+										const parser = protocolMap[protocol]
+										if (parser) {
+											return [protocol, parser(content)]
+										} else {
+											return [protocol, null]
+										}
+									})
+									.filter(([, b]) => b !== null) as [string, unknown][]
+							)
+						: {}
+					acc.push({ ...data, id })
+				}
+
+				return acc
+			}, [])
+		}
+
+		//TODO: implement side list
+		//const sideListNode = getBinaryNodeChild(usyncNode, 'side_list')
+		return queryResult
+	}
+
+	withDeviceProtocol() {
+		this.protocols.push(new USyncDeviceProtocol())
+		return this
+	}
+
+	withContactProtocol() {
+		this.protocols.push(new USyncContactProtocol())
+		return this
+	}
+
+	withStatusProtocol() {
+		this.protocols.push(new USyncStatusProtocol())
+		return this
+	}
+
+	withDisappearingModeProtocol() {
+		this.protocols.push(new USyncDisappearingModeProtocol())
+		return this
+	}
+
+	withBotProfileProtocol() {
+		this.protocols.push(new USyncBotProfileProtocol())
+		return this
+	}
+
+	withLIDProtocol() {
+		this.protocols.push(new USyncLIDProtocol())
+		return this
+	}
+}

package/src/WAUSync/USyncUser.ts

@@ -0,0 +1,32 @@
+export class USyncUser {
+	id?: string
+	lid?: string
+	phone?: string
+	type?: string
+	personaId?: string
+
+	withId(id: string) {
+		this.id = id
+		return this
+	}
+
+	withLid(lid: string) {
+		this.lid = lid
+		return this
+	}
+
+	withPhone(phone: string) {
+		this.phone = phone
+		return this
+	}
+
+	withType(type: string) {
+		this.type = type
+		return this
+	}
+
+	withPersonaId(personaId: string) {
+		this.personaId = personaId
+		return this
+	}
+}

package/src/WAUSync/index.ts

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

package/src/index.ts

@@ -0,0 +1,13 @@
+import makeWASocket from './Socket/index'
+
+export * from '../WAProto/index.js'
+export * from './Utils/index'
+export * from './Types/index'
+export * from './Defaults/index'
+export * from './WABinary/index'
+export * from './WAM/index'
+export * from './WAUSync/index'
+
+export type WASocket = ReturnType<typeof makeWASocket>
+export { makeWASocket }
+export default makeWASocket