[Error sending message after 2 hour periode]

[centratelemedia]

Describe the bug Error sending message

My Whatsapp Service Class

import { Boom } from '@hapi/boom'
import makeWASocket, { AnyMessageContent, delay, DisconnectReason, fetchLatestBaileysVersion, isJidBroadcast, makeCacheableSignalKeyStore, makeInMemoryStore, MessageRetryMap, useMultiFileAuthState } from '../src'
import MAIN_LOGGER from '../src/Utils/logger'

const logger = MAIN_LOGGER.child({})
logger.level = 'trace'

const useStore = !process.argv.includes('--no-store')
const doReplies = !process.argv.includes('--no-reply')

// external map to store retry counts of messages when decryption/encryption fails
// keep this out of the socket itself, so as to prevent a message decryption/encryption loop across socket restarts
const msgRetryCounterMap: MessageRetryMap = {}

// the store maintains the data of the WA connection in memory
// can be written out to a file & read from it
const store = useStore ? makeInMemoryStore({ logger }) : undefined
store?.readFromFile('./baileys_store_multi.json')
// save every 10s
setInterval(() => {
    store?.writeToFile('./baileys_store_multi.json')
}, 10_000)
export class WhatsAppService {

    qrcode: string = "";
    phoneNumber: string = "";
    sock: any;
    constructor() {

    }
    async initialize() {
        this.sock = await this.createNewSocket();
    }
    async createNewSocket() {
        const { state, saveCreds } = await useMultiFileAuthState('baileys_auth_info')
        // fetch latest version of WA Web
        const { version, isLatest } = await fetchLatestBaileysVersion()
        console.log(`using WA v${version.join('.')}, isLatest: ${isLatest}`)

        const sock = makeWASocket({
            version,
            logger,
            printQRInTerminal: true,
            auth: {
                creds: state.creds,
                /** caching makes the store faster to send/recv messages */
                keys: makeCacheableSignalKeyStore(state.keys, logger),
            },
            msgRetryCounterMap,
            generateHighQualityLinkPreview: true,
            // ignore all broadcast messages -- to receive the same
            // comment the line below out
            shouldIgnoreJid: jid => isJidBroadcast(jid),
            // implement to handle retries
            getMessage: async key => {
                if (store) {
                    const msg = await store.loadMessage(key.remoteJid!, key.id!)
                    return msg?.message || undefined
                }

                // only if store is present
                return {
                    conversation: 'hello'
                }
            }
        });
        store?.bind(sock.ev)

        // the process function lets you process all events that just occurred
        // efficiently in a batch
        sock.ev.process(
            // events is a map for event name => event data
            async (events) => {
                // something about the connection changed
                // maybe it closed, or we received all offline message or connection opened
                if (events['connection.update']) {
                    const update = events['connection.update']
                    const { connection, lastDisconnect } = update
                    if (connection === 'close') {
                        // reconnect if not logged out
                        if ((lastDisconnect?.error as Boom)?.output?.statusCode !== DisconnectReason.loggedOut) {
                            this.initialize()
                        } else {
                            console.log('Connection closed. You are logged out.')
                        }
                    }

                    console.log('connection update', update)
                }

                // credentials updated -- save them
                if (events['creds.update']) {
                    await saveCreds()
                }

                if (events.call) {
                    console.log('recv call event', events.call)
                }

                // history received
                if (events['messaging-history.set']) {
                    const { chats, contacts, messages, isLatest } = events['messaging-history.set']
                    console.log(`recv ${chats.length} chats, ${contacts.length} contacts, ${messages.length} msgs (is latest: ${isLatest})`)
                }

                // received a new message
                if (events['messages.upsert']) {
                    const upsert = events['messages.upsert']
                    console.log('recv messages ', JSON.stringify(upsert, undefined, 2))

                    if (upsert.type === 'notify') {
                        for (const msg of upsert.messages) {
                            if (!msg.key.fromMe && doReplies) {
                                //console.log('replying to', msg.key.remoteJid)
                                //await sock!.readMessages([msg.key])
                                //await sendMessageWTyping({ text: 'Hello there!' }, msg.key.remoteJid!)
                            }
                        }
                    }
                }

                // messages updated like status delivered, message deleted etc.
                if (events['messages.update']) {
                    console.log(events['messages.update'])
                }

                if (events['message-receipt.update']) {
                    console.log(events['message-receipt.update'])
                }

                if (events['messages.reaction']) {
                    console.log(events['messages.reaction'])
                }

                if (events['presence.update']) {
                    console.log(events['presence.update'])
                }

                if (events['chats.update']) {
                    console.log(events['chats.update'])
                }

                if (events['contacts.update']) {
                    for (const contact of events['contacts.update']) {
                        if (typeof contact.imgUrl !== 'undefined') {
                            const newUrl = contact.imgUrl === null
                                ? null
                                : await sock!.profilePictureUrl(contact.id!).catch(() => null)
                            console.log(
                                `contact ${contact.id} has a new profile pic: ${newUrl}`,
                            )
                        }
                    }
                }

                if (events['chats.delete']) {
                    console.log('chats deleted ', events['chats.delete'])
                }
            }
        )

        return sock
    }

    async sendMessageWTyping(phoneNumber: string,msg: AnyMessageContent) {
        try {
            const jid = FormatToWhatsappJid(phoneNumber);
            await this.sock.presenceSubscribe(jid)
            await delay(500)

            await this.sock.sendPresenceUpdate('composing', jid)
            await delay(1000)

            await this.sock.sendPresenceUpdate('paused', jid)


            await this.sock.sendMessage(jid, {
                text: msg
            })
        } catch (e) {
            console.log(e);
        }
    }
    GetStatus() {
        if (this.qrcode === "") {
            return {
                isConnected: true,
                phoneNumber: this.phoneNumber,
                qrcode: ""
            };
        }
        return {
            isConnected: false,
            phoneNumber: "",
            qrcode: this.qrcode
        };
    }
    Logout() {
        this.sock.logout();
    }
}

function FormatToWhatsappJid(phoneNumber: string) {
    if (typeof (phoneNumber) == 'undefined' || phoneNumber == '') {
        return "";
    }

    phoneNumber = phoneNumber.replace(/\D/g, '');
    if (phoneNumber.startsWith('+')) {
        phoneNumber = phoneNumber.substring(1);
    }
    if (phoneNumber.startsWith('08')) {
        phoneNumber = '62' + phoneNumber.substring(1);
    }
    if (!phoneNumber.endsWith('@s.whatsapp.net')) {
        phoneNumber = phoneNumber + '@s.whatsapp.net';
    }
    return phoneNumber;
}

My API (ExpressJs) to send message

import express from 'express';
import QRCode from 'qrcode';
import { validator } from './helper/Validator';
import {MessageWrite} from './rules/MessageWrite'
import { WhatsAppService } from './WhatsAppService';
const wa: WhatsAppService = new WhatsAppService();
const app: express.Application = express();
wa.initialize();
app.use(express.json())
app.get('/status', (req: any, res: any) => {
    //res.send(wa.GetStatus());
});

app.post('/message', (req: any, res: any) => {
    validator(req.body, MessageWrite, {}, (error: any, isValid: boolean) => {
        if (!isValid) {
            res.status(400);
            res.send({
                status: "failed",
                errors: error.errors
            });
        } else {
            const message = req.body.message;
            const phoneNumber = req.body.phoneNumber;
            console.log('phoneNumber=>'+phoneNumber);
            console.log('message=>'+message);
            
            wa.sendMessageWTyping(phoneNumber, message);

            res.send({
                status: "success",
                errors: null
            });
        }
    });
});

Environment (please complete the following information):

• Is this on a server? PC Desktop

Error log

Error: Timed Out
    at D:\projects\nodejs\Baileys\src\Utils\generics.ts:150:5 {
  data: {
    stack: 'Error\n' +
      '    at promiseTimeout (D:\\projects\\nodejs\\Baileys\\src\\Utils\\generics.ts:144:16)\n' +
      '    at waitForMessage (D:\\projects\\nodejs\\Baileys\\src\\Socket\\socket.ts:128:39)\n' +
      '    at query (D:\\projects\\nodejs\\Baileys\\src\\Socket\\socket.ts:155:16)\n' +
      '    at assertSessions (D:\\projects\\nodejs\\Baileys\\src\\Socket\\messages-send.ts:226:25)\n' +
      '    at async D:\\projects\\nodejs\\Baileys\\src\\Socket\\messages-send.ts:435:6\n' +
      '    at async Object.transaction (D:\\projects\\nodejs\\Baileys\\src\\Utils\\auth-utils.ts:152:6)\n' +
      '    at async relayMessage (D:\\projects\\nodejs\\Baileys\\src\\Socket\\messages-send.ts:329:3)\n' +
      '    at async Object.sendMessage (D:\\projects\\nodejs\\Baileys\\src\\Socket\\messages-send.ts:654:5)\n' +
      '    at async WhatsAppService.sendMessageWTyping (D:\\projects\\nodejs\\Baileys\\app\\WhatsAppService.ts:177:13)'
  },
  isBoom: true,
  isServer: false,
  output: {
    statusCode: 408,
    payload: {
      statusCode: 408,
      error: 'Request Time-out',
      message: 'Timed Out'
    },
    headers: {}
  }
}

anyone can help how to solve this problem?