dcodeindra-baileyspro 2.3.9

package/lib/Utils/index.js

@@ -0,0 +1,35 @@
+"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("./generics"), exports)
+__exportStar(require("./decode-wa-message"), exports)
+__exportStar(require("./messages"), exports)
+__exportStar(require("./messages-media"), exports)
+__exportStar(require("./validate-connection"), exports)
+__exportStar(require("./crypto"), exports)
+__exportStar(require("./signal"), exports)
+__exportStar(require("./noise-handler"), exports)
+__exportStar(require("./history"), exports)
+__exportStar(require("./chat-utils"), exports)
+__exportStar(require("./lt-hash"), exports)
+__exportStar(require("./auth-utils"), exports)
+__exportStar(require("./baileys-event-stream"), exports)
+__exportStar(require("./use-mongo-file-auth-state"), exports)
+__exportStar(require("./use-single-file-auth-state"), exports)
+__exportStar(require("./use-multi-file-auth-state"), exports)
+__exportStar(require("./link-preview"), exports)
+__exportStar(require("./event-buffer"), exports)
+__exportStar(require("./process-message"), exports)

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,21 @@
+import { AxiosRequestConfig } from 'axios'
+import { WAMediaUploadFunction, WAUrlInfo } from '../Types'
+import { ILogger } from './logger'
+export type URLGenerationOptions = {
+thumbnailWidth: number
+fetchOpts: {
+/** Timeout in ms */
+timeout: number
+proxyUrl?: string
+headers?: AxiosRequestConfig<{}>['headers']
+}
+uploadImage?: WAMediaUploadFunction
+logger?: ILogger
+}
+/**
+* Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+* Return undefined if the fetch failed or no URL was found
+* @param text first matched URL in text
+* @returns the URL info required to generate link preview
+*/
+export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>

package/lib/Utils/link-preview.js

@@ -0,0 +1,112 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+Object.defineProperty(o, "default", { enumerable: true, value: v })
+}) : function(o, v) {
+o["default"] = v
+})
+var __importStar = (this && this.__importStar) || function (mod) {
+if (mod && mod.__esModule) return mod
+var result = {}
+if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
+__setModuleDefault(result, mod)
+return result
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+const messages_1 = require("./messages")
+const messages_media_1 = require("./messages-media")
+const THUMBNAIL_WIDTH_PX = 192
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+const stream = await messages_media_1.getHttpStream(url, fetchOpts)
+const result = await messages_media_1.extractImageThumb(stream, thumbnailWidth)
+return result
+}
+/**
+* Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+* Return undefined if the fetch failed or no URL was found
+* @param text first matched URL in text
+* @returns the URL info required to generate link preview
+*/
+const getUrlInfo = async (text, opts = { thumbnailWidth: THUMBNAIL_WIDTH_PX, fetchOpts: { timeout: 3000 }}) => {
+try {
+const retries = 0
+const maxRetry = 5
+const { getLinkPreview } = await Promise.resolve().then(() => __importStar(require('link-preview-js')))
+let previewLink = text
+if (!text.startsWith('https://') && !text.startsWith('http://')) {
+previewLink = 'https://' + previewLink
+}
+const info = await getLinkPreview(previewLink, {
+...opts.fetchOpts,
+followRedirects: 'follow',
+handleRedirects: (baseURL, forwardedURL) => {
+const urlObj = new URL(baseURL)
+const forwardedURLObj = new URL(forwardedURL)
+if (retries >= maxRetry) {
+return false
+}
+if (forwardedURLObj.hostname === urlObj.hostname
+|| forwardedURLObj.hostname === 'www.' + urlObj.hostname
+|| 'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+retries + 1
+return true
+}
+else {
+return false
+}
+},
+headers: opts.fetchOpts
+})
+if (info && 'title' in info && info.title) {
+const [image] = info.images
+const urlInfo = {
+'canonical-url': info.url,
+'matched-text': text,
+title: info.title,
+description: info.description,
+originalThumbnailUrl: image
+}
+if (opts.uploadImage) {
+const { imageMessage } = await messages_1.prepareWAMessageMedia({ image: { url: image } }, {
+upload: opts.uploadImage,
+mediaTypeOverride: 'thumbnail-link',
+options: opts.fetchOpts
+})
+urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail
+? Buffer.from(imageMessage.jpegThumbnail)
+: undefined
+urlInfo.highQualityThumbnail = imageMessage || undefined
+}
+else {
+try {
+urlInfo.jpegThumbnail = image
+? (await getCompressedJpegThumbnail(image, opts)).buffer
+: undefined
+}
+catch (error) {
+opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail')
+}
+}
+return urlInfo
+}
+}
+catch (error) {
+if (!error.message.includes('receive a valid')) {
+throw error
+}
+}
+}
+module.exports = {
+getUrlInfo
+}

package/lib/Utils/logger.d.ts

@@ -0,0 +1,11 @@
+export interface ILogger {
+level: string
+child(obj: Record<string, unknown>): ILogger
+trace(obj: unknown, msg?: string): any
+debug(obj: unknown, msg?: string): any
+info(obj: unknown, msg?: string): any
+warn(obj: unknown, msg?: string): any
+error(obj: unknown, msg?: string): any
+}
+declare const _default: import("pino").Logger<never, boolean>
+export default _default

package/lib/Utils/logger.js

@@ -0,0 +1,7 @@
+"use strict"
+var __importDefault = (this && this.__importDefault) || function (mod) {
+return (mod && mod.__esModule) ? mod : { "default": mod }
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+const pino_1 = __importDefault(require("pino"))
+exports.default = pino_1.default({ timestamp: () => `,"time":"${new Date().toJSON()}"` })

package/lib/Utils/lt-hash.d.ts

@@ -0,0 +1,12 @@
+declare class d {
+salt: string
+constructor(e: string)
+add(e: any, t: any): any
+subtract(e: any, t: any): any
+subtractThenAdd(e: any, t: any, r: any): any
+_addSingle(e: any, t: any): Promise<ArrayBuffer>
+_subtractSingle(e: any, t: any): Promise<ArrayBuffer>
+performPointwiseWithOverflow(e: any, t: any, r: any): ArrayBuffer
+}
+export declare const LT_HASH_ANTI_TAMPERING: d
+export {}

package/lib/Utils/lt-hash.js

@@ -0,0 +1,53 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+const crypto_1 = require("./crypto")
+/**
+* LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+* over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+* if the same series of mutations was made sequentially.
+*/
+const o = 128
+class d {
+constructor(e) {
+this.salt = e
+}
+add(e, t) {
+var r = this
+for (const item of t) {
+e = r._addSingle(e, item)
+}
+return e
+}
+subtract(e, t) {
+var r = this
+for (const item of t) {
+e = r._subtractSingle(e, item)
+}
+return e
+}
+subtractThenAdd(e, t, r) {
+var n = this
+return n.add(n.subtract(e, r), t)
+}
+async _addSingle(e, t) {
+var r = this
+const n = new Uint8Array(await crypto_1.hkdf(Buffer.from(t), o, { info: r.salt })).buffer
+return r.performPointwiseWithOverflow(await e, n, ((e, t) => e + t))
+}
+async _subtractSingle(e, t) {
+var r = this
+const n = new Uint8Array(await crypto_1.hkdf(Buffer.from(t), o, { info: r.salt })).buffer
+return r.performPointwiseWithOverflow(await e, n, ((e, t) => e - t))
+}
+performPointwiseWithOverflow(e, t, r) {
+const n = new DataView(e), i = new DataView(t), a = new ArrayBuffer(n.byteLength), s = new DataView(a)
+for (let e = 0; e < n.byteLength; e += 2) {
+s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0)
+}
+return a
+}
+}
+const LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity')
+module.exports = {
+LT_HASH_ANTI_TAMPERING
+}

package/lib/Utils/make-mutex.d.ts

@@ -0,0 +1,7 @@
+export declare const makeMutex: () => {
+mutex<T>(code: () => T | Promise<T>): Promise<T>
+}
+export type Mutex = ReturnType<typeof makeMutex>
+export declare const makeKeyedMutex: () => {
+mutex<T>(key: string, task: () => T | Promise<T>): Promise<T>
+}

package/lib/Utils/make-mutex.js

@@ -0,0 +1,45 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+const makeMutex = () => {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let task = Promise.resolve()
+let taskTimeout
+return {
+mutex(code) {
+task = (async () => {
+// wait for the previous task to complete
+// if there is an error, we swallow so as to not block the queue
+try {
+await task
+}
+catch (_a) { }
+try {
+// execute the current task
+const result = await code()
+return result
+}
+finally {
+clearTimeout(taskTimeout)
+}
+})()
+// we replace the existing task, appending the new piece of execution to it
+// so the next task will have to wait for this one to finish
+return task
+},
+}
+}
+const makeKeyedMutex = () => {
+const map = {}
+return {
+mutex(key, task) {
+if (!map[key]) {
+map[key] = makeMutex()
+}
+return map[key].mutex(task)
+}
+}
+}
+module.exports = {
+makeMutex, 
+makeKeyedMutex
+}

package/lib/Utils/messages-media.d.ts

@@ -0,0 +1,104 @@
+import { Boom } from '@hapi/boom'
+import { AxiosRequestConfig } from 'axios'
+import { Readable, Transform } from 'stream'
+import { URL } from 'url'
+import { proto } from '../../WAProto'
+import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types'
+import { BinaryNode } from '../WABinary'
+import { ILogger } from './logger'
+export declare const hkdfInfoKey: (type: MediaType) => string
+/** generates all the keys required to encrypt/decrypt & sign a media message */
+export declare function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): MediaDecryptionKeyInfo
+export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+buffer: Buffer
+original: {
+width: number | undefined
+height: number | undefined
+}
+}>
+export declare const encodeBase64EncodedStringForUpload: (b64: string) => string
+export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
+img: Buffer
+}>
+/** gets the SHA256 of the given media message */
+export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined
+export declare function getAudioDuration(buffer: Buffer | string | Readable): Promise<number | undefined>
+/**
+referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
+*/
+export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): Promise<Uint8Array | undefined>
+export declare const toReadable: (buffer: Buffer) => Readable
+export declare const toBuffer: (stream: Readable) => Promise<Buffer>
+export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
+readonly stream: Readable
+readonly type: "buffer"
+} | {
+readonly stream: Readable
+readonly type: "readable"
+} | {
+readonly stream: Readable
+readonly type: "remote"
+} | {
+readonly stream: import("fs").ReadStream
+readonly type: "file"
+}>
+/** generates a thumbnail for a given media, if required */
+export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
+logger?: Logger
+}): Promise<{
+thumbnail: string | undefined
+originalImageDimensions: {
+width: number
+height: number
+} | undefined
+}>
+export declare const getHttpStream: (url: string | URL, options?: AxiosRequestConfig & {
+isStream?: true
+}) => Promise<Readable>
+type EncryptedStreamOptions = {
+saveOriginalFileIfRequired?: boolean
+logger?: Logger
+opts?: AxiosRequestConfig
+}
+export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+mediaKey: Buffer
+encWriteStream: Readable
+bodyPath: string | undefined
+mac: Buffer
+fileEncSha256: Buffer
+fileSha256: Buffer
+fileLength: number
+didSaveToTmpPath: boolean
+}>
+export type MediaDownloadOptions = {
+startByte?: number
+endByte?: number
+options?: AxiosRequestConfig<{}>
+}
+export declare const getUrlFromDirectPath: (directPath: string) => string
+export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>
+/**
+* Decrypts and downloads an AES256-CBC encrypted file given the keys.
+* Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
+* */
+export declare const downloadEncryptedContent: (downloadUrl: string, { cipherKey, iv }: MediaDecryptionKeyInfo, { startByte, endByte, options }?: MediaDownloadOptions) => Promise<Transform>
+export declare function extensionForMediaMessage(message: WAMessageContent): string
+export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logger, options }: SocketConfig, refreshMediaConn: (force: boolean) => Promise<MediaConnInfo>) => WAMediaUploadFunction
+/**
+* Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
+*/
+export declare const encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode
+export declare const decodeMediaRetryNode: (node: BinaryNode) => {
+key: proto.IMessageKey
+media?: {
+ciphertext: Uint8Array
+iv: Uint8Array
+} | undefined
+error?: Boom<any> | undefined
+}
+export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
+ciphertext: Uint8Array
+iv: Uint8Array
+}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>
+export declare const getStatusCodeForMediaRetry: (code: number) => any
+export {}