@sixcore/baileys 1.0.0 → 1.0.2

package/src/WAM/encode.ts

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

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

package/src/WAUSync/Protocols/USyncContactProtocol.ts

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

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

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

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

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

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

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

package/src/WAUSync/USyncQuery.ts

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

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

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

package/src/index.ts

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