gifted-baileys 1.5.6 → 1.5.7

package/src/Socket/socket.ts

@@ -1,777 +0,0 @@
-import { Boom } from '@hapi/boom'
-import { randomBytes } from 'crypto'
-import { URL } from 'url'
-import { promisify } from 'util'
-import { proto } from '../../WAProto'
-import {
-	DEF_CALLBACK_PREFIX,
-	DEF_TAG_PREFIX,
-	INITIAL_PREKEY_COUNT,
-	MIN_PREKEY_COUNT,
-	MOBILE_ENDPOINT,
-	MOBILE_NOISE_HEADER,
-	MOBILE_PORT,
-	NOISE_WA_HEADER
-} from '../Defaults'
-import { DisconnectReason, SocketConfig } from '../Types'
-import {
-	addTransactionCapability,
-	aesEncryptCTR,
-	bindWaitForConnectionUpdate,
-	bytesToCrockford,
-	configureSuccessfulPairing,
-	Curve,
-	derivePairingCodeKey,
-	generateLoginNode,
-	generateMdTagPrefix,
-	generateMobileNode,
-	generateRegistrationNode,
-	getCodeFromWSError,
-	getErrorCodeFromStreamError,
-	getNextPreKeysNode,
-	makeEventBuffer,
-	makeNoiseHandler,
-	printQRIfNecessaryListener,
-	promiseTimeout
-} from '../Utils'
-import {
-	assertNodeErrorFree,
-	BinaryNode,
-	binaryNodeToString,
-	encodeBinaryNode,
-	getBinaryNodeChild,
-	getBinaryNodeChildren,
-	jidEncode,
-	S_WHATSAPP_NET
-} from '../WABinary'
-import { MobileSocketClient, WebSocketClient } from './Client'
-
-/**
- * Connects to WA servers and performs:
- * - simple queries (no retry mechanism, wait for connection establishment)
- * - listen to messages and emit events
- * - query phone connection
- */
-
-export const makeSocket = (config: SocketConfig) => {
-	const {
-		waWebSocketUrl,
-		connectTimeoutMs,
-		logger,
-		keepAliveIntervalMs,
-		browser,
-		auth: authState,
-		printQRInTerminal,
-		defaultQueryTimeoutMs,
-		transactionOpts,
-		qrTimeout,
-		makeSignalRepository,
-	} = config
-
-	let url = typeof waWebSocketUrl === 'string' ? new URL(waWebSocketUrl) : waWebSocketUrl
-
-	config.mobile = config.mobile || url.protocol === 'tcp:'
-
-	if(config.mobile && url.protocol !== 'tcp:') {
-		url = new URL(`tcp://${MOBILE_ENDPOINT}:${MOBILE_PORT}`)
-	}
-
-	if(!config.mobile && url.protocol === 'wss' && authState?.creds?.routingInfo) {
-		url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'))
-	}
-
-	const ws = config.socket ? config.socket : config.mobile ? new MobileSocketClient(url, config) : new WebSocketClient(url, config)
-
-	ws.connect()
-
-	const ev = makeEventBuffer(logger)
-	/** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
-	const ephemeralKeyPair = Curve.generateKeyPair()
-	/** WA noise protocol wrapper */
-	const noise = makeNoiseHandler({
-		keyPair: ephemeralKeyPair,
-		NOISE_HEADER: config.mobile ? MOBILE_NOISE_HEADER : NOISE_WA_HEADER,
-		mobile: config.mobile,
-		logger,
-		routingInfo: authState?.creds?.routingInfo
-	})
-
-	const { creds } = authState
-	// add transaction capability
-	const keys = addTransactionCapability(authState.keys, logger, transactionOpts)
-	const signalRepository = makeSignalRepository({ creds, keys })
-
-	let lastDateRecv: Date
-	let epoch = 1
-	let keepAliveReq: NodeJS.Timeout
-	let qrTimer: NodeJS.Timeout
-	let closed = false
-
-	const uqTagId = generateMdTagPrefix()
-	const generateMessageTag = () => `${uqTagId}${epoch++}`
-
-	const sendPromise = promisify(ws.send)
-	/** send a raw buffer */
-	const sendRawMessage = async(data: Uint8Array | Buffer) => {
-		if(!ws.isOpen) {
-			throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed })
-		}
-
-		const bytes = noise.encodeFrame(data)
-		await promiseTimeout<void>(
-			connectTimeoutMs,
-			async(resolve, reject) => {
-				try {
-					await sendPromise.call(ws, bytes)
-					resolve()
-				} catch(error) {
-					reject(error)
-				}
-			}
-		)
-	}
-
-	/** send a binary node */
-	const sendNode = (frame: BinaryNode) => {
-		if(logger.level === 'trace') {
-			logger.trace({ xml: binaryNodeToString(frame), msg: 'xml send' })
-		}
-
-		const buff = encodeBinaryNode(frame)
-		return sendRawMessage(buff)
-	}
-
-	/** log & process any unexpected errors */
-	const onUnexpectedError = (err: Error | Boom, msg: string) => {
-		logger.error(
-			{ err },
-			`unexpected error in '${msg}'`
-		)
-	}
-
-	/** await the next incoming message */
-	const awaitNextMessage = async<T>(sendMsg?: Uint8Array) => {
-		if(!ws.isOpen) {
-			throw new Boom('Connection Closed', {
-				statusCode: DisconnectReason.connectionClosed
-			})
-		}
-
-		let onOpen: (data: T) => void
-		let onClose: (err: Error) => void
-
-		const result = promiseTimeout<T>(connectTimeoutMs, (resolve, reject) => {
-			onOpen = resolve
-			onClose = mapWebSocketError(reject)
-			ws.on('frame', onOpen)
-			ws.on('close', onClose)
-			ws.on('error', onClose)
-		})
-			.finally(() => {
-				ws.off('frame', onOpen)
-				ws.off('close', onClose)
-				ws.off('error', onClose)
-			})
-
-		if(sendMsg) {
-			sendRawMessage(sendMsg).catch(onClose!)
-		}
-
-		return result
-	}
-
-	/**
-	 * Wait for a message with a certain tag to be received
-	 * @param msgId the message tag to await
-	 * @param timeoutMs timeout after which the promise will reject
-	 */
-	const waitForMessage = async<T>(msgId: string, timeoutMs = defaultQueryTimeoutMs) => {
-		let onRecv: (json) => void
-		let onErr: (err) => void
-		try {
-			return await promiseTimeout<T>(timeoutMs,
-				(resolve, reject) => {
-					onRecv = resolve
-					onErr = err => {
-						reject(err || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }))
-					}
-
-					ws.on(`TAG:${msgId}`, onRecv)
-					ws.on('close', onErr) // if the socket closes, you'll never receive the message
-					ws.off('error', onErr)
-				},
-			)
-		} finally {
-			ws.off(`TAG:${msgId}`, onRecv!)
-			ws.off('close', onErr!) // if the socket closes, you'll never receive the message
-			ws.off('error', onErr!)
-		}
-	}
-
-	/** send a query, and wait for its response. auto-generates message ID if not provided */
-	const query = async(node: BinaryNode, timeoutMs?: number) => {
-		if(!node.attrs.id) {
-			node.attrs.id = generateMessageTag()
-		}
-
-		const msgId = node.attrs.id
-		const wait = waitForMessage(msgId, timeoutMs)
-
-		await sendNode(node)
-
-		const result = await (wait as Promise<BinaryNode>)
-		if('tag' in result) {
-			assertNodeErrorFree(result)
-		}
-
-		return result
-	}
-
-	/** connection handshake */
-	const validateConnection = async() => {
-		let helloMsg: proto.IHandshakeMessage = {
-			clientHello: { ephemeral: ephemeralKeyPair.public }
-		}
-		helloMsg = proto.HandshakeMessage.fromObject(helloMsg)
-
-		logger.info({ browser, helloMsg }, 'connected to WA')
-
-		const init = proto.HandshakeMessage.encode(helloMsg).finish()
-
-		const result = await awaitNextMessage<Uint8Array>(init)
-		const handshake = proto.HandshakeMessage.decode(result)
-
-		logger.trace({ handshake }, 'handshake recv from WA')
-
-		const keyEnc = noise.processHandshake(handshake, creds.noiseKey)
-
-		let node: proto.IClientPayload
-		if(config.mobile) {
-			node = generateMobileNode(config)
-		} else if(!creds.me) {
-			node = generateRegistrationNode(creds, config)
-			logger.info({ node }, 'not logged in, attempting registration...')
-		} else {
-			node = generateLoginNode(creds.me.id, config)
-			logger.info({ node }, 'logging in...')
-		}
-
-		const payloadEnc = noise.encrypt(
-			proto.ClientPayload.encode(node).finish()
-		)
-		await sendRawMessage(
-			proto.HandshakeMessage.encode({
-				clientFinish: {
-					static: keyEnc,
-					payload: payloadEnc,
-				},
-			}).finish()
-		)
-		noise.finishInit()
-		startKeepAliveRequest()
-	}
-
-	const getAvailablePreKeysOnServer = async() => {
-		const result = await query({
-			tag: 'iq',
-			attrs: {
-				id: generateMessageTag(),
-				xmlns: 'encrypt',
-				type: 'get',
-				to: S_WHATSAPP_NET
-			},
-			content: [
-				{ tag: 'count', attrs: {} }
-			]
-		})
-		const countChild = getBinaryNodeChild(result, 'count')
-		return +countChild!.attrs.value
-	}
-
-	/** generates and uploads a set of pre-keys to the server */
-	const uploadPreKeys = async(count = INITIAL_PREKEY_COUNT) => {
-		await keys.transaction(
-			async() => {
-				logger.info({ count }, 'uploading pre-keys')
-				const { update, node } = await getNextPreKeysNode({ creds, keys }, count)
-
-				await query(node)
-				ev.emit('creds.update', update)
-
-				logger.info({ count }, 'uploaded pre-keys')
-			}
-		)
-	}
-
-	const uploadPreKeysToServerIfRequired = async() => {
-		const preKeyCount = await getAvailablePreKeysOnServer()
-		logger.info(`${preKeyCount} pre-keys found on server`)
-		if(preKeyCount <= MIN_PREKEY_COUNT) {
-			await uploadPreKeys()
-		}
-	}
-
-	const onMessageReceived = (data: Buffer) => {
-		noise.decodeFrame(data, frame => {
-			// reset ping timeout
-			lastDateRecv = new Date()
-
-			let anyTriggered = false
-
-			anyTriggered = ws.emit('frame', frame)
-			// if it's a binary node
-			if(!(frame instanceof Uint8Array)) {
-				const msgId = frame.attrs.id
-
-				if(logger.level === 'trace') {
-					logger.trace({ xml: binaryNodeToString(frame), msg: 'recv xml' })
-				}
-
-				/* Check if this is a response to a message we sent */
-				anyTriggered = ws.emit(`${DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered
-				/* Check if this is a response to a message we are expecting */
-				const l0 = frame.tag
-				const l1 = frame.attrs || {}
-				const l2 = Array.isArray(frame.content) ? frame.content[0]?.tag : ''
-
-				Object.keys(l1).forEach(key => {
-					anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered
-					anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered
-					anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}`, frame) || anyTriggered
-				})
-				anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered
-				anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered
-
-				if(!anyTriggered && logger.level === 'debug') {
-					logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv')
-				}
-			}
-		})
-	}
-
-	const end = (error: Error | undefined) => {
-		if(closed) {
-			logger.trace({ trace: error?.stack }, 'connection already closed')
-			return
-		}
-
-		closed = true
-		logger.info(
-			{ trace: error?.stack },
-			error ? 'connection errored' : 'connection closed'
-		)
-
-		clearInterval(keepAliveReq)
-		clearTimeout(qrTimer)
-
-		ws.removeAllListeners('close')
-		ws.removeAllListeners('error')
-		ws.removeAllListeners('open')
-		ws.removeAllListeners('message')
-
-		if(!ws.isClosed && !ws.isClosing) {
-			try {
-				ws.close()
-			} catch{ }
-		}
-
-		ev.emit('connection.update', {
-			connection: 'close',
-			lastDisconnect: {
-				error,
-				date: new Date()
-			}
-		})
-		ev.removeAllListeners('connection.update')
-	}
-
-	const waitForSocketOpen = async() => {
-		if(ws.isOpen) {
-			return
-		}
-
-		if(ws.isClosed || ws.isClosing) {
-			throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed })
-		}
-
-		let onOpen: () => void
-		let onClose: (err: Error) => void
-		await new Promise((resolve, reject) => {
-			onOpen = () => resolve(undefined)
-			onClose = mapWebSocketError(reject)
-			ws.on('open', onOpen)
-			ws.on('close', onClose)
-			ws.on('error', onClose)
-		})
-			.finally(() => {
-				ws.off('open', onOpen)
-				ws.off('close', onClose)
-				ws.off('error', onClose)
-			})
-	}
-
-	const startKeepAliveRequest = () => (
-		keepAliveReq = setInterval(() => {
-			if(!lastDateRecv) {
-				lastDateRecv = new Date()
-			}
-
-			const diff = Date.now() - lastDateRecv.getTime()
-			/*
-				check if it's been a suspicious amount of time since the server responded with our last seen
-				it could be that the network is down
-			*/
-			if(diff > keepAliveIntervalMs + 5000) {
-				end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }))
-			} else if(ws.isOpen) {
-				// if its all good, send a keep alive request
-				query(
-					{
-						tag: 'iq',
-						attrs: {
-							id: generateMessageTag(),
-							to: S_WHATSAPP_NET,
-							type: 'get',
-							xmlns: 'w:p',
-						},
-						content: [{ tag: 'ping', attrs: {} }]
-					}
-				)
-					.catch(err => {
-						logger.error({ trace: err.stack }, 'error in sending keep alive')
-					})
-			} else {
-				logger.warn('keep alive called when WS not open')
-			}
-		}, keepAliveIntervalMs)
-	)
-	/** i have no idea why this exists. pls enlighten me */
-	const sendPassiveIq = (tag: 'passive' | 'active') => (
-		query({
-			tag: 'iq',
-			attrs: {
-				to: S_WHATSAPP_NET,
-				xmlns: 'passive',
-				type: 'set',
-			},
-			content: [
-				{ tag, attrs: {} }
-			]
-		})
-	)
-
-	/** logout & invalidate connection */
-	const logout = async(msg?: string) => {
-		const jid = authState.creds.me?.id
-		if(jid) {
-			await sendNode({
-				tag: 'iq',
-				attrs: {
-					to: S_WHATSAPP_NET,
-					type: 'set',
-					id: generateMessageTag(),
-					xmlns: 'md'
-				},
-				content: [
-					{
-						tag: 'remove-companion-device',
-						attrs: {
-							jid,
-							reason: 'user_initiated'
-						}
-					}
-				]
-			})
-		}
-
-		end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }))
-	}
-
-	const requestPairingCode = async(phoneNumber: string): Promise<string> => {
-		authState.creds.pairingCode = bytesToCrockford(randomBytes(5))
-		authState.creds.me = {
-			id: jidEncode(phoneNumber, 's.whatsapp.net'),
-			name: '~'
-		}
-		ev.emit('creds.update', authState.creds)
-		await sendNode({
-			tag: 'iq',
-			attrs: {
-				to: S_WHATSAPP_NET,
-				type: 'set',
-				id: generateMessageTag(),
-				xmlns: 'md'
-			},
-			content: [
-				{
-					tag: 'link_code_companion_reg',
-					attrs: {
-						jid: authState.creds.me.id,
-						stage: 'companion_hello',
-						// eslint-disable-next-line camelcase
-						should_show_push_notification: 'true'
-					},
-					content: [
-						{
-							tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
-							attrs: {},
-							content: await generatePairingKey()
-						},
-						{
-							tag: 'companion_server_auth_key_pub',
-							attrs: {},
-							content: authState.creds.noiseKey.public
-						},
-						{
-							tag: 'companion_platform_id',
-							attrs: {},
-							content: '49' // Chrome
-						},
-						{
-							tag: 'companion_platform_display',
-							attrs: {},
-							content: `${browser[1]} (${browser[0]})`
-						},
-						{
-							tag: 'link_code_pairing_nonce',
-							attrs: {},
-							content: '0'
-						}
-					]
-				}
-			]
-		})
-		return authState.creds.pairingCode
-	}
-
-	async function generatePairingKey() {
-		const salt = randomBytes(32)
-		const randomIv = randomBytes(16)
-		const key = derivePairingCodeKey(authState.creds.pairingCode!, salt)
-		const ciphered = aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv)
-		return Buffer.concat([salt, randomIv, ciphered])
-	}
-
-	const sendWAMBuffer = (wamBuffer: Buffer) => {
-		return query({
-			tag: 'iq',
-			attrs: {
-				to: S_WHATSAPP_NET,
-				id: generateMessageTag(),
-				xmlns: 'w:stats'
-			},
-			content: [
-				{
-					tag: 'add',
-					attrs: {},
-					content: wamBuffer
-				}
-			]
-		})
-	}
-
-	ws.on('message', onMessageReceived)
-
-	ws.on('open', async() => {
-		try {
-			await validateConnection()
-		} catch(err) {
-			logger.error({ err }, 'error in validating connection')
-			end(err)
-		}
-	})
-	ws.on('error', mapWebSocketError(end))
-	ws.on('close', () => end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })))
-	// the server terminated the connection
-	ws.on('CB:xmlstreamend', () => end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })))
-	// QR gen
-	ws.on('CB:iq,type:set,pair-device', async(stanza: BinaryNode) => {
-		const iq: BinaryNode = {
-			tag: 'iq',
-			attrs: {
-				to: S_WHATSAPP_NET,
-				type: 'result',
-				id: stanza.attrs.id,
-			}
-		}
-		await sendNode(iq)
-
-		const pairDeviceNode = getBinaryNodeChild(stanza, 'pair-device')
-		const refNodes = getBinaryNodeChildren(pairDeviceNode, 'ref')
-		const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64')
-		const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString('base64')
-		const advB64 = creds.advSecretKey
-
-		let qrMs = qrTimeout || 60_000 // time to let a QR live
-		const genPairQR = () => {
-			if(!ws.isOpen) {
-				return
-			}
-
-			const refNode = refNodes.shift()
-			if(!refNode) {
-				end(new Boom('QR refs attempts ended', { statusCode: DisconnectReason.timedOut }))
-				return
-			}
-
-			const ref = (refNode.content as Buffer).toString('utf-8')
-			const qr = [ref, noiseKeyB64, identityKeyB64, advB64].join(',')
-
-			ev.emit('connection.update', { qr })
-
-			qrTimer = setTimeout(genPairQR, qrMs)
-			qrMs = qrTimeout || 20_000 // shorter subsequent qrs
-		}
-
-		genPairQR()
-	})
-	// device paired for the first time
-	// if device pairs successfully, the server asks to restart the connection
-	ws.on('CB:iq,,pair-success', async(stanza: BinaryNode) => {
-		logger.debug('pair success recv')
-		try {
-			const { reply, creds: updatedCreds } = configureSuccessfulPairing(stanza, creds)
-
-			logger.info(
-				{ me: updatedCreds.me, platform: updatedCreds.platform },
-				'pairing configured successfully, expect to restart the connection...'
-			)
-
-			ev.emit('creds.update', updatedCreds)
-			ev.emit('connection.update', { isNewLogin: true, qr: undefined })
-
-			await sendNode(reply)
-		} catch(error) {
-			logger.info({ trace: error.stack }, 'error in pairing')
-			end(error)
-		}
-	})
-	// login complete
-	ws.on('CB:success', async(node: BinaryNode) => {
-		await uploadPreKeysToServerIfRequired()
-		await sendPassiveIq('active')
-
-		logger.info('opened connection to WA')
-		clearTimeout(qrTimer) // will never happen in all likelyhood -- but just in case WA sends success on first try
-
-		ev.emit('creds.update', { me: { ...authState.creds.me!, lid: node.attrs.lid } })
-
-		ev.emit('connection.update', { connection: 'open' })
-	})
-
-	ws.on('CB:stream:error', (node: BinaryNode) => {
-		logger.error({ node }, 'stream errored out')
-
-		const { reason, statusCode } = getErrorCodeFromStreamError(node)
-
-		end(new Boom(`Stream Errored (${reason})`, { statusCode, data: node }))
-	})
-	// stream fail, possible logout
-	ws.on('CB:failure', (node: BinaryNode) => {
-		const reason = +(node.attrs.reason || 500)
-		end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }))
-	})
-
-	ws.on('CB:ib,,downgrade_webclient', () => {
-		end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }))
-	})
-
-	ws.on('CB:ib,,edge_routing', (node: BinaryNode) => {
-		const edgeRoutingNode = getBinaryNodeChild(node, 'edge_routing')
-		const routingInfo = getBinaryNodeChild(edgeRoutingNode, 'routing_info')
-		if(routingInfo?.content) {
-			authState.creds.routingInfo = Buffer.from(routingInfo?.content as Uint8Array)
-		}
-	})
-
-	let didStartBuffer = false
-	process.nextTick(() => {
-		if(creds.me?.id) {
-			// start buffering important events
-			// if we're logged in
-			ev.buffer()
-			didStartBuffer = true
-		}
-
-		ev.emit('connection.update', { connection: 'connecting', receivedPendingNotifications: false, qr: undefined })
-	})
-
-	// called when all offline notifs are handled
-	ws.on('CB:ib,,offline', (node: BinaryNode) => {
-		const child = getBinaryNodeChild(node, 'offline')
-		const offlineNotifs = +(child?.attrs.count || 0)
-
-		logger.info(`handled ${offlineNotifs} offline messages/notifications`)
-		if(didStartBuffer) {
-			ev.flush()
-			logger.trace('flushed events for initial buffer')
-		}
-
-		ev.emit('connection.update', { receivedPendingNotifications: true })
-	})
-
-	// update credentials when required
-	ev.on('creds.update', update => {
-		const name = update.me?.name
-		// if name has just been received
-		if(creds.me?.name !== name) {
-			logger.debug({ name }, 'updated pushName')
-			sendNode({
-				tag: 'presence',
-				attrs: { name: name! }
-			})
-				.catch(err => {
-					logger.warn({ trace: err.stack }, 'error in sending presence update on name change')
-				})
-		}
-
-		Object.assign(creds, update)
-	})
-
-	if(printQRInTerminal) {
-		printQRIfNecessaryListener(ev, logger)
-	}
-
-	return {
-		type: 'md' as 'md',
-		ws,
-		ev,
-		authState: { creds, keys },
-		signalRepository,
-		get user() {
-			return authState.creds.me
-		},
-		generateMessageTag,
-		query,
-		waitForMessage,
-		waitForSocketOpen,
-		sendRawMessage,
-		sendNode,
-		logout,
-		end,
-		onUnexpectedError,
-		uploadPreKeys,
-		uploadPreKeysToServerIfRequired,
-		requestPairingCode,
-		/** Waits for the connection to WA to reach a state */
-		waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
-		sendWAMBuffer,
-	}
-}
-
-/**
- * map the websocket error to the right type
- * so it can be retried by the caller
- * */
-function mapWebSocketError(handler: (err: Error) => void) {
-	return (error: Error) => {
-		handler(
-			new Boom(
-				`WebSocket Error (${error?.message})`,
-				{ statusCode: getCodeFromWSError(error), data: error }
-			)
-		)
-	}
-}
-
-export type Socket = ReturnType<typeof makeSocket>