dcodeindra-baileyspro 2.3.9

package/lib/Types/Product.d.ts

@@ -0,0 +1,78 @@
+import { WAMediaUpload } from './Message'
+export type CatalogResult = {
+data: {
+paging: {
+cursors: {
+before: string
+after: string
+}
+}
+data: any[]
+}
+}
+export type ProductCreateResult = {
+data: {
+product: {}
+}
+}
+export type CatalogStatus = {
+status: string
+canAppeal: boolean
+}
+export type CatalogCollection = {
+id: string
+name: string
+products: Product[]
+status: CatalogStatus
+}
+export type ProductAvailability = 'in stock'
+export type ProductBase = {
+name: string
+retailerId?: string
+url?: string
+description: string
+price: number
+currency: string
+isHidden?: boolean
+}
+export type ProductCreate = ProductBase & {
+/** ISO country code for product origin. Set to undefined for no country */
+originCountryCode: string | undefined
+/** images of the product */
+images: WAMediaUpload[]
+}
+export type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>
+export type Product = ProductBase & {
+id: string
+imageUrls: {
+[_: string]: string
+}
+reviewStatus: {
+[_: string]: string
+}
+availability: ProductAvailability
+}
+export type OrderPrice = {
+currency: string
+total: number
+}
+export type OrderProduct = {
+id: string
+imageUrl: string
+name: string
+quantity: number
+currency: string
+price: number
+}
+export type OrderDetails = {
+price: OrderPrice
+products: OrderProduct[]
+}
+export type CatalogCursor = string
+export type GetCatalogOptions = {
+/** cursor to start from */
+cursor?: CatalogCursor
+/** number of products to fetch */
+limit?: number
+jid?: string
+}

package/lib/Types/Product.js

@@ -0,0 +1,2 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })

package/lib/Types/Signal.d.ts

@@ -0,0 +1,57 @@
+import { proto } from '../../WAProto'
+type DecryptGroupSignalOpts = {
+group: string
+authorJid: string
+msg: Uint8Array
+}
+type ProcessSenderKeyDistributionMessageOpts = {
+item: proto.Message.ISenderKeyDistributionMessage
+authorJid: string
+}
+type DecryptSignalProtoOpts = {
+jid: string
+type: 'pkmsg' | 'msg'
+ciphertext: Uint8Array
+}
+type EncryptMessageOpts = {
+jid: string
+data: Uint8Array
+}
+type EncryptGroupMessageOpts = {
+group: string
+data: Uint8Array
+meId: string
+}
+type PreKey = {
+keyId: number
+publicKey: Uint8Array
+}
+type SignedPreKey = PreKey & {
+signature: Uint8Array
+}
+type E2ESession = {
+registrationId: number
+identityKey: Uint8Array
+signedPreKey: SignedPreKey
+preKey: PreKey
+}
+type E2ESessionOpts = {
+jid: string
+session: E2ESession
+}
+export type SignalRepository = {
+decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>
+processSenderKeyDistributionMessage(opts: ProcessSenderKeyDistributionMessageOpts): Promise<void>
+decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>
+encryptMessage(opts: EncryptMessageOpts): Promise<{
+type: 'pkmsg' | 'msg'
+ciphertext: Uint8Array
+}>
+encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
+senderKeyDistributionMessage: Uint8Array
+ciphertext: Uint8Array
+}>
+injectE2ESession(opts: E2ESessionOpts): Promise<void>
+jidToSignalProtocolAddress(jid: string): string
+}
+export {}

package/lib/Types/Signal.js

@@ -0,0 +1,2 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })

package/lib/Types/Socket.d.ts

@@ -0,0 +1,116 @@
+import { AxiosRequestConfig } from 'axios'
+import type { Agent } from 'https'
+import { ILogger } from '../Utils/logger'
+import type { URL } from 'url'
+import { proto } from '../../WAProto'
+import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth'
+import { GroupMetadata } from './GroupMetadata'
+import { MediaConnInfo } from './Message'
+import { SignalRepository } from './Signal'
+export type WAVersion = [number, number, number]
+export type WABrowserDescription = [string, string, string]
+export type CacheStore = {
+/** get a cached key and change the stats */
+get<T>(key: string): T | undefined
+/** set a key in the cache */
+set<T>(key: string, value: T): void
+/** delete a key from the cache */
+del(key: string): void
+/** flush all data */
+flushAll(): void
+}
+export type SocketConfig = {
+/** the WS url to connect to WA */
+waWebSocketUrl: string | URL
+/** Fails the connection if the socket times out in this interval */
+connectTimeoutMs: number
+/** Default timeout for queries, undefined for no timeout */
+defaultQueryTimeoutMs: number | undefined
+/** ping-pong interval for WS connection */
+keepAliveIntervalMs: number
+/** should baileys use the mobile api instead of the multi device api
+* @deprecated This feature has been removed
+*/
+mobile?: boolean
+/** proxy agent */
+agent?: Agent
+/** logger */
+logger: ILogger
+/** version to connect with */
+version: WAVersion
+/** override browser config */
+browser: WABrowserDescription
+/** agent used for fetch requests -- uploading/downloading media */
+fetchAgent?: Agent
+/** should the QR be printed in the terminal */
+printQRInTerminal: boolean
+/** should events be emitted for actions done by this socket connection */
+emitOwnEvents: boolean
+/** custom upload hosts to upload media to */
+customUploadHosts: MediaConnInfo['hosts']
+/** time to wait between sending new retry requests */
+retryRequestDelayMs: number
+/** max retry count */
+maxMsgRetryCount: number
+/** time to wait for the generation of the next QR in ms */
+qrTimeout?: number
+/** provide an auth state object to maintain the auth state */
+auth: AuthenticationState
+/** manage history processing with this control by default will sync up everything */
+shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean
+/** transaction capability options for SignalKeyStore */
+transactionOpts: TransactionCapabilityOptions
+/** marks the client as online whenever the socket successfully connects */
+markOnlineOnConnect: boolean
+/** alphanumeric country code (USA -> US) for the number used */
+countryCode: string
+/** provide a cache to store media, so does not have to be re-uploaded */
+mediaCache?: CacheStore
+/**
+* map to store the retry counts for failed messages
+* used to determine whether to retry a message or not */
+msgRetryCounterCache?: CacheStore
+/** provide a cache to store a user's device list */
+userDevicesCache?: CacheStore
+/** cache to store call offers */
+callOfferCache?: CacheStore
+/** cache to track placeholder resends */
+placeholderResendCache?: CacheStore
+/** width for link preview images */
+linkPreviewImageThumbnailWidth: number
+/** Should Baileys ask the phone for full history, will be received async */
+syncFullHistory: boolean
+/** Should baileys fire init queries automatically, default true */
+fireInitQueries: boolean
+/**
+* generate a high quality link preview,
+* entails uploading the jpegThumbnail to WA
+* */
+generateHighQualityLinkPreview: boolean
+/**
+* Returns if a jid should be ignored,
+* no event for that jid will be triggered.
+* Messages from that jid will also not be decrypted
+* */
+shouldIgnoreJid: (jid: string) => boolean | undefined
+/**
+* Optionally patch the message before sending out
+* */
+patchMessageBeforeSending: (msg: proto.IMessage, recipientJids: string[]) => Promise<proto.IMessage> | proto.IMessage
+/** verify app state MACs */
+appStateMacVerification: {
+patch: boolean
+snapshot: boolean
+}
+/** options for axios */
+options: AxiosRequestConfig<{}>
+/**
+* fetch a message from your store
+* implement this so that messages failed to send
+* (solves the "this message can take a while" issue) can be retried
+* */
+getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>
+/** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
+cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>
+makeSignalRepository: (auth: SignalAuthState) => SignalRepository
+}

package/lib/Types/Socket.js

@@ -0,0 +1,2 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })

package/lib/Types/State.d.ts

@@ -0,0 +1,27 @@
+import { Contact } from './Contact'
+export type WAConnectionState = 'open' | 'connecting' | 'close'
+export type ConnectionState = {
+/** connection is now open, connecting or closed */
+connection: WAConnectionState
+/** the error that caused the connection to close */
+lastDisconnect?: {
+error: Error | undefined
+date: Date
+}
+/** is this a new login */
+isNewLogin?: boolean
+/** the current QR code */
+qr?: string
+/** has the device received all pending notifications while it was offline */
+receivedPendingNotifications?: boolean
+/** legacy connection options */
+legacy?: {
+phoneConnected: boolean
+user?: Contact
+}
+/**
+* if the client is shown as an active, online client.
+* If this is false, the primary phone and other devices will receive notifs
+* */
+isOnline?: boolean
+}

package/lib/Types/State.js

@@ -0,0 +1,2 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })

package/lib/Types/USync.d.ts

@@ -0,0 +1,25 @@
+import { BinaryNode } from '../WABinary'
+import { USyncUser } from '../WAUSync'
+/**
+* Defines the interface for a USyncQuery protocol
+*/
+export interface USyncQueryProtocol {
+/**
+* The name of the protocol
+*/
+name: string
+/**
+* Defines what goes inside the query part of a USyncQuery
+*/
+getQueryElement: () => BinaryNode
+/**
+* Defines what goes inside the user part of a USyncQuery
+*/
+getUserElement: (user: USyncUser) => BinaryNode | null
+/**
+* Parse the result of the query
+* @param data Data from the result
+* @returns Whatever the protocol is supposed to return
+*/
+parser: (data: BinaryNode) => unknown
+}

package/lib/Types/USync.js

@@ -0,0 +1,2 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })

package/lib/Types/index.d.ts

@@ -0,0 +1,70 @@
+export * from './Auth'
+export * from './GroupMetadata'
+export * from './Chat'
+export * from './Contact'
+export * from './State'
+export * from './Message'
+export * from './Newsletter'
+export * from './Socket'
+export * from './Events'
+export * from './Product'
+export * from './Call'
+export * from './Signal'
+import { AuthenticationState } from './Auth'
+import { SocketConfig } from './Socket'
+export type UserFacingSocketConfig = Partial<SocketConfig> & {
+auth: AuthenticationState
+}
+export type BrowsersMap = {
+ubuntu(browser: string): [string, string, string]
+macOS(browser: string): [string, string, string]
+windows(browser: string): [string, string, string]
+linux(browser: string): [string, string, string]
+android(browser: string): [string, string, string]
+iOS(browser: string): [string, string, string]
+baileys(browser: string): [string, string, string]
+kaiOS(browser: string): [string, string, string]
+chromeOS(browser: string): [string, string, string]
+appropriate(browser: string): [string, string, string]
+custom(platform: string, browser: string, version: string): [string, string, string]
+}
+export declare const enum DisconnectReason {
+connectionClosed = 428,
+connectionLost = 408,
+connectionReplaced = 440,
+timedOut = 408,
+loggedOut = 401,
+badSession = 500,
+restartRequired = 515,
+multideviceMismatch = 411,
+forbidden = 403,
+unavailableService = 503
+}
+export type WAInitResponse = {
+ref: string
+ttl: number
+status: 200
+}
+export type WABusinessHoursConfig = {
+day_of_week: string
+mode: string
+open_time?: number
+close_time?: number
+}
+export type WABusinessProfile = {
+description: string
+email: string | undefined
+business_hours: {
+timezone?: string
+config?: WABusinessHoursConfig[]
+business_config?: WABusinessHoursConfig[]
+}
+website: string[]
+category?: string
+wid?: string
+address?: string
+}
+export type CurveKeyPair = {
+private: Uint8Array
+public: Uint8Array
+}

package/lib/Types/index.js

@@ -0,0 +1,42 @@
+"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 })
+exports.DisconnectReason = void 0;
+__exportStar(require("./Auth"), exports)
+__exportStar(require("./GroupMetadata"), exports)
+__exportStar(require("./Chat"), exports)
+__exportStar(require("./Contact"), exports)
+__exportStar(require("./State"), exports)
+__exportStar(require("./Message"), exports)
+__exportStar(require("./Newsletter"), exports)
+__exportStar(require("./Socket"), exports)
+__exportStar(require("./Events"), exports)
+__exportStar(require("./Product"), exports)
+__exportStar(require("./Call"), exports)
+__exportStar(require("./Signal"), exports)
+const DisconnectReason = {
+connectionClosed: 428,
+connectionLost: 408,
+connectionReplaced: 440,
+timedOut: 408,
+loggedOut: 401,
+badSession: 500,
+restartRequired: 515,
+multideviceMismatch: 411,
+forbidden: 403,
+unavailableService: 503
+}
+exports.DisconnectReason = DisconnectReason

package/lib/Utils/auth-utils.d.ts

@@ -0,0 +1,18 @@
+import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types'
+import { ILogger } from './logger'
+/**
+* Adds caching capability to a SignalKeyStore
+* @param store the store to add caching to
+* @param logger to log trace events
+* @param _cache cache store to use
+*/
+export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger?: ILogger, _cache?: CacheStore): SignalKeyStore
+/**
+* Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+* this allows batch read & write operations & improves the performance of the lib
+* @param state the key store to apply this capability to
+* @param logger logger to log events
+* @returns SignalKeyStore with transaction capability
+*/
+export declare const addTransactionCapability: (state: SignalKeyStore, logger?: ILogger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction
+export declare const initAuthCreds: () => AuthenticationCreds

package/lib/Utils/auth-utils.js

@@ -0,0 +1,198 @@
+"use strict"
+var __importDefault = (this && this.__importDefault) || function (mod) {
+return (mod && mod.__esModule) ? mod : { "default": mod }
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+const crypto_1 = require("crypto")
+const node_cache_1 = __importDefault(require("@cacheable/node-cache"))
+const Defaults_1 = require("../Defaults")
+const crypto_2 = require("./crypto")
+const generics_1 = require("./generics")
+/**
+* Adds caching capability to a SignalKeyStore
+* @param store the store to add caching to
+* @param logger to log trace events
+* @param _cache cache store to use
+*/
+function makeCacheableSignalKeyStore(store, logger, _cache) {
+const cache = _cache || new node_cache_1.default({
+stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+useClones: false,
+deleteOnExpire: true,
+})
+function getUniqueId(type, id) {
+return `${type}.${id}`
+}
+return {
+async get(type, ids) {
+const data = {}
+const idsToFetch = []
+for (const id of ids) {
+const item = cache.get(getUniqueId(type, id))
+if (typeof item !== 'undefined') {
+data[id] = item
+}
+else {
+idsToFetch.push(id)
+}
+}
+if (idsToFetch.length) {
+logger?.trace({ items: idsToFetch.length }, 'loading from store')
+const fetched = await store.get(type, idsToFetch)
+for (const id of idsToFetch) {
+const item = fetched[id]
+if (item) {
+data[id] = item
+cache.set(getUniqueId(type, id), item)
+}
+}
+}
+return data
+},
+async set(data) {
+let keys = 0
+for (const type in data) {
+for (const id in data[type]) {
+cache.set(getUniqueId(type, id), data[type][id])
+keys += 1
+}
+}
+logger?.trace({ keys }, 'updated cache')
+await store.set(data)
+},
+async clear() {
+cache.flushAll()
+await store.clear?.call(store)
+}
+}
+}
+/**
+* Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+* this allows batch read & write operations & improves the performance of the lib
+* @param state the key store to apply this capability to
+* @param logger logger to log events
+* @returns SignalKeyStore with transaction capability
+*/
+const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+// number of queries made to the DB during the transaction
+// only there for logging purposes
+let dbQueriesInTransaction = 0
+let transactionCache = {}
+let mutations = {}
+let transactionsInProgress = 0
+return {
+get: async (type, ids) => {
+if (isInTransaction()) {
+const dict = transactionCache[type]
+const idsRequiringFetch = dict
+? ids.filter(item => typeof dict[item] === 'undefined')
+: ids
+// only fetch if there are any items to fetch
+if (idsRequiringFetch.length) {
+dbQueriesInTransaction += 1
+const result = await state.get(type, idsRequiringFetch)
+transactionCache[type] || (transactionCache[type] = {})
+Object.assign(transactionCache[type], result)
+}
+return ids.reduce((dict, id) => {
+const value = transactionCache[type]?.[id]
+if (value) {
+dict[id] = value
+}
+return dict
+}, {})
+}
+else {
+return state.get(type, ids)
+}
+},
+set: data => {
+if (isInTransaction()) {
+logger.trace({ types: Object.keys(data) }, 'caching in transaction')
+for (const key in data) {
+transactionCache[key] = transactionCache[key] || {}
+Object.assign(transactionCache[key], data[key])
+mutations[key] = mutations[key] || {}
+Object.assign(mutations[key], data[key])
+}
+}
+else {
+return state.set(data)
+}
+},
+isInTransaction,
+async transaction(work) {
+let result
+transactionsInProgress += 1
+if (transactionsInProgress === 1) {
+logger.trace('entering transaction')
+}
+try {
+result = await work()
+// commit if this is the outermost transaction
+if (transactionsInProgress === 1) {
+if (Object.keys(mutations).length) {
+logger.trace('committing transaction')
+// retry mechanism to ensure we've some recovery
+// in case a transaction fails in the first attempt
+let tries = maxCommitRetries
+while (tries) {
+tries -= 1
+try {
+await state.set(mutations)
+logger.trace({ dbQueriesInTransaction }, 'committed transaction')
+break
+}
+catch (error) {
+logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`)
+await generics_1.delay(delayBetweenTriesMs)
+}
+}
+}
+else {
+logger.trace('no mutations in transaction')
+}
+}
+}
+finally {
+transactionsInProgress -= 1
+if (transactionsInProgress === 0) {
+transactionCache = {}
+mutations = {}
+dbQueriesInTransaction = 0
+}
+}
+return result
+}
+}
+function isInTransaction() {
+return transactionsInProgress > 0
+}
+}
+const initAuthCreds = () => {
+const identityKey = crypto_2.Curve.generateKeyPair()
+return {
+noiseKey: crypto_2.Curve.generateKeyPair(),
+pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
+signedIdentityKey: identityKey,
+signedPreKey: crypto_2.signedKeyPair(identityKey, 1),
+registrationId: generics_1.generateRegistrationId(),
+advSecretKey: crypto_1.randomBytes(32).toString('base64'),
+processedHistoryMessages: [],
+nextPreKeyId: 1,
+firstUnuploadedPreKeyId: 1,
+accountSyncCounter: 0,
+accountSettings: {
+unarchiveChats: false
+},
+registered: false,
+pairingCode: undefined,
+lastPropHash: undefined,
+routingInfo: undefined
+}
+}
+module.exports = {
+makeCacheableSignalKeyStore, 
+addTransactionCapability, 
+initAuthCreds
+}

package/lib/Utils/baileys-event-stream.d.ts

@@ -0,0 +1,16 @@
+import type { BaileysEventEmitter } from '../Types'
+/**
+* Captures events from a baileys event emitter & stores them in a file
+* @param ev The event emitter to read events from
+* @param filename File to save to
+*/
+export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void
+/**
+* Read event file and emit events from there
+* @param filename filename containing event data
+* @param delayIntervalMs delay between each event emit
+*/
+export declare const readAndEmitEventStream: (filename: string, delayIntervalMs?: number) => {
+ev: BaileysEventEmitter
+task: Promise<void>
+}