@neelegirl/baileys 1.4.3

package/src/Types/Signal.d.ts

@@ -0,0 +1,68 @@
+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/src/Types/Signal.js

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

package/src/Types/Socket.d.ts

@@ -0,0 +1,120 @@
+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/src/Types/Socket.js

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

package/src/Types/State.d.ts

@@ -0,0 +1,29 @@
+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/src/Types/State.js

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

package/src/Types/USync.d.ts

@@ -0,0 +1,26 @@
+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/src/Types/USync.js

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

package/src/Types/index.d.ts

@@ -0,0 +1,78 @@
+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/src/Types/index.js

@@ -0,0 +1,47 @@
+"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/src/Utils/auth-utils.d.ts

@@ -0,0 +1,21 @@
+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/src/Utils/auth-utils.js

@@ -0,0 +1,205 @@
+"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/src/Utils/baileys-event-stream.d.ts

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