voice-calls-baileys 1.0.7 → 1.0.8

package/lib/demo.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -34,12 +44,13 @@ async function connectToWhatsApp() {
     const sock = (0, baileys_1.default)({
         printQRInTerminal: true,
         auth: state,
-        browser: baileys_1.Browsers.macOS('Desktop'),
+        browser: baileys_1.Browsers.windows("UWP"),
+        version: [2, 3000, 1031141796, 257538, 0],
         logger: (0, pino_1.default)({ level: "error" }),
         syncFullHistory: false,
         markOnlineOnConnect: false
     });
-    (0, transport_model_1.useVoiceCallsBaileys)("your token", sock, "close", true);
+    (0, transport_model_1.useVoiceCallsBaileys)("<Your Wavoip Token>", sock, "<Your Software Name>", "close", true);
     sock.ev.on("creds.update", saveCreds);
     sock.ev.on('connection.update', (update) => {
         var _a, _b;

package/lib/services/transport.model.d.ts

@@ -1,4 +1,4 @@
 import { Socket } from "socket.io-client";
 import { ClientToServerEvents, ServerToClientEvents } from "./transport.type";
 import { WAConnectionState, WASocket } from "baileys";
-export declare const useVoiceCallsBaileys: (wavoip_token: string, baileys_sock: WASocket, status?: WAConnectionState, logger?: boolean) => Promise<Socket<ServerToClientEvents, ClientToServerEvents>>;
+export declare const useVoiceCallsBaileys: (wavoip_token: string, baileys_sock: WASocket, softwareBase: string, status?: WAConnectionState, logger?: boolean) => Promise<Socket<ServerToClientEvents, ClientToServerEvents>>;

package/lib/services/transport.model.js

@@ -3,152 +3,102 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useVoiceCallsBaileys = void 0;
 const socket_io_client_1 = require("socket.io-client");
 let baileys_connection_state = "close";
-const useVoiceCallsBaileys = async (wavoip_token, baileys_sock, status, logger) => {
-    baileys_connection_state = status !== null && status !== void 0 ? status : "close";
+const useVoiceCallsBaileys = async (wavoip_token, baileys_sock, softwareBase, status, logger) => {
     const socket = (0, socket_io_client_1.io)("https://devices.wavoip.com/baileys", {
         transports: ["websocket"],
         path: `/${wavoip_token}/websocket`
     });
     socket.on("connect", () => {
         if (logger)
-            console.log("[*] - Wavoip connected", socket.id);
-        socket.emit("init", baileys_sock.authState.creds.me, baileys_sock.authState.creds.account, baileys_connection_state);
+            console.log("[Wavoip] - Connected", socket.id);
+        socket.emit("init", baileys_sock.authState.creds.me, baileys_sock.authState.creds.account, status !== null && status !== void 0 ? status : "close", softwareBase);
     });
     socket.on("disconnect", () => {
         if (logger)
-            console.log("[*] - Wavoip disconnect");
+            console.log("[Wavoip] - Disconnected");
     });
     socket.on("connect_error", (error) => {
-        if (socket.active) {
-            if (logger)
-                console.log("[*] - Wavoip connection error temporary failure, the socket will automatically try to reconnect", error);
-        }
-        else {
-            if (logger)
-                console.log("[*] - Wavoip connection error", error.message);
-        }
+        if (logger)
+            console.log("[Wavoip] - Connection lost");
     });
-    socket.on("onWhatsApp", async (jid, callback) => {
-        try {
-            const response = await baileys_sock.onWhatsApp(jid);
-            callback(response);
-            if (logger)
-                console.log("[*] Success on call onWhatsApp function", response, jid);
-        }
-        catch (error) {
-            if (logger)
-                console.error("[*] Error on call onWhatsApp function", error);
-        }
+    socket.on("onWhatsApp", (jid, callback) => {
+        baileys_sock.onWhatsApp(jid)
+            .then((response) => callback(response))
+            .catch((error) => {
+            callback({ wavoipStatus: "error", result: error });
+            if (logger)
+                console.log("[Wavoip] - Failed to call onWhatsapp, error: ", error);
+        });
     });
     socket.on("profilePictureUrl", async (jid, type, timeoutMs, callback) => {
-        try {
-            const response = await baileys_sock.profilePictureUrl(jid, type, timeoutMs);
-            callback(response);
+        baileys_sock.profilePictureUrl(jid, type, timeoutMs)
+            .then((response) => callback(response))
+            .catch((error) => {
+            callback({ wavoipStatus: "error", result: error });
             if (logger)
-                console.log("[*] Success on call profilePictureUrl function", response);
-        }
-        catch (error) {
-            if (logger)
-                console.error("[*] Error on call profilePictureUrl function", error);
-        }
+                console.log("[Wavoip] - Failed to call profilePictureUrl, error: ", error);
+        });
     });
     socket.on("assertSessions", async (jids, force, callback) => {
-        try {
-            const response = await baileys_sock.assertSessions(jids, force);
-            callback(response);
-            if (logger)
-                console.log("[*] Success on call assertSessions function", response);
-        }
-        catch (error) {
+        baileys_sock.assertSessions(jids, force)
+            .then((response) => callback(response))
+            .catch((error) => {
+            callback({ wavoipStatus: "error", result: error });
             if (logger)
-                console.error("[*] Error on call assertSessions function", error);
-        }
+                console.log("[Wavoip] - Failed to call assertSessions, error: ", error);
+        });
     });
     socket.on("createParticipantNodes", async (jids, message, extraAttrs, callback) => {
-        try {
-            const response = await baileys_sock.createParticipantNodes(jids, message, extraAttrs);
-            callback(response, true);
-            if (logger)
-                console.log("[*] Success on call createParticipantNodes function", response);
-        }
-        catch (error) {
+        baileys_sock.createParticipantNodes(jids, message, extraAttrs)
+            .then((response) => callback(response.nodes, response.shouldIncludeDeviceIdentity))
+            .catch((error) => {
+            callback({ wavoipStatus: "error", result: error });
             if (logger)
-                console.error("[*] Error on call createParticipantNodes function", error);
-        }
+                console.log("[Wavoip] - Failed to call createParticipantNodes, error: ", error);
+        });
     });
     socket.on("getUSyncDevices", async (jids, useCache, ignoreZeroDevices, callback) => {
-        try {
-            const response = await baileys_sock.getUSyncDevices(jids, useCache, ignoreZeroDevices);
-            callback(response);
-            if (logger)
-                console.log("[*] Success on call getUSyncDevices function", response);
-        }
-        catch (error) {
+        baileys_sock.getUSyncDevices(jids, useCache, ignoreZeroDevices)
+            .then((response) => callback(response))
+            .catch((error) => {
+            callback({ wavoipStatus: "error", result: error });
             if (logger)
-                console.error("[*] Error on call getUSyncDevices function", error);
-        }
-    });
-    socket.on("generateMessageTag", async (callback) => {
-        try {
-            const response = await baileys_sock.generateMessageTag();
-            callback(response);
-            if (logger)
-                console.log("[*] Success on call generateMessageTag function", response);
-        }
-        catch (error) {
-            if (logger)
-                console.error("[*] Error on call generateMessageTag function", error);
-        }
+                console.log("[Wavoip] - Failed to call createParticipantNodes, error: ", error);
+        });
     });
+    socket.on("generateMessageTag", (callback) => callback(baileys_sock.generateMessageTag()));
     socket.on("sendNode", async (stanza, callback) => {
-        try {
-            const response = await baileys_sock.sendNode(stanza);
-            callback(true);
+        baileys_sock.sendNode(stanza)
+            .then((response) => callback(true))
+            .catch((error) => {
+            callback({ wavoipStatus: "error", result: error });
             if (logger)
-                console.log("[*] Success on call sendNode function", response);
-        }
-        catch (error) {
-            if (logger)
-                console.error("[*] Error on call sendNode function", error);
-        }
+                console.log("[Wavoip] - Failed to call createParticipantNodes, error: ", error);
+        });
     });
     socket.on("signalRepository:decryptMessage", async (jid, type, ciphertext, callback) => {
-        try {
-            const response = await baileys_sock.signalRepository.decryptMessage({
-                jid: jid,
-                type: type,
-                ciphertext: ciphertext,
-            });
-            callback(response);
-            if (logger)
-                console.log("[*] Success on call signalRepository:decryptMessage function", response);
-        }
-        catch (error) {
+        baileys_sock.signalRepository.decryptMessage({ jid: jid, type: type, ciphertext: ciphertext })
+            .then((response) => callback(response))
+            .catch((error) => {
+            callback({ wavoipStatus: "error", result: error });
             if (logger)
-                console.error("[*] Error on call signalRepository:decryptMessage function", error);
-        }
+                console.log("[Wavoip] - Failed to call decryptMessage, error: ", error);
+        });
     });
-    // we only use this connection data to inform the webphone that the device is connected and creeds account to generate e2e whatsapp key for make call packets
     baileys_sock.ev.on("connection.update", (update) => {
         const { connection } = update;
         if (connection) {
-            baileys_connection_state = connection;
-            socket
-                .timeout(1000)
-                .emit("connection.update:status", baileys_sock.authState.creds.me, baileys_sock.authState.creds.account, connection);
+            console.log(connection);
+            socket.timeout(1000).emit("connection.update:status", baileys_sock.authState.creds.me, baileys_sock.authState.creds.account, connection);
         }
         if (update.qr) {
             socket.timeout(1000).emit("connection.update:qr", update.qr);
         }
     });
     baileys_sock.ws.on("CB:call", (packet) => {
-        if (logger)
-            console.log("[*] Signling received");
         socket.volatile.timeout(1000).emit("CB:call", packet);
     });
     baileys_sock.ws.on("CB:ack,class:call", (packet) => {
-        if (logger)
-            console.log("[*] Signling ack received");
         socket.volatile.timeout(1000).emit("CB:ack,class:call", packet);
     });
     return socket;

package/lib/services/transport.type.d.ts

@@ -11,28 +11,35 @@ export interface ServerToClientEvents {
     "signalRepository:decryptMessage": SignalRepositoryDecryptMessageType;
 }
 export interface ClientToServerEvents {
-    "init": (me: Contact | undefined, account: proto.IADVSignedDeviceIdentity | undefined, status: WAConnectionState) => void;
+    "init": (me: Contact | undefined, account: proto.IADVSignedDeviceIdentity | undefined, status: WAConnectionState, softwareBase: string) => void;
     "CB:call": (packet: any) => void;
     "CB:ack,class:call": (packet: any) => void;
     "connection.update:status": (me: Contact | undefined, account: proto.IADVSignedDeviceIdentity | undefined, status: WAConnectionState) => void;
     "connection.update:qr": (qr: string) => void;
 }
+export type FailedResponseType = {
+    wavoipStatus: string;
+    result: any;
+};
 export type onWhatsAppType = (jid: string, callback: onWhatsAppCallback) => void;
 export type onWhatsAppCallback = (response: {
     exists: boolean;
     jid: string;
-}[]) => void;
+}[] | FailedResponseType | undefined) => void;
 export type ProfilePictureUrlType = (jid: string, type: "image" | "preview", timeoutMs: number | undefined, callback: ProfilePictureUrlCallback) => void;
-export type ProfilePictureUrlCallback = (response: string | undefined) => void;
+export type ProfilePictureUrlCallback = (response: string | FailedResponseType | undefined) => void;
 export type AssertSessionsType = (jids: string[], force: boolean, callback: AssertSessionsCallback) => void;
-export type AssertSessionsCallback = (response: boolean) => void;
+export type AssertSessionsCallback = (response: boolean | FailedResponseType) => void;
 export type CreateParticipantNodesType = (jids: string[], message: any, extraAttrs: any, callback: CreateParticipantNodesCallback) => void;
-export type CreateParticipantNodesCallback = (nodes: any, shouldIncludeDeviceIdentity: boolean) => void;
+export type CreateParticipantNodesCallback = {
+    (nodes: any, shouldIncludeDeviceIdentity: boolean): void;
+    (response: FailedResponseType): void;
+};
 export type GetUSyncDevicesType = (jids: string[], useCache: boolean, ignoreZeroDevices: boolean, callback: GetUSyncDevicesTypeCallback) => void;
-export type GetUSyncDevicesTypeCallback = (jids: JidWithDevice[]) => void;
+export type GetUSyncDevicesTypeCallback = (jids: JidWithDevice[] | FailedResponseType) => void;
 export type GenerateMessageTagType = (callback: GenerateMessageTagTypeCallback) => void;
-export type GenerateMessageTagTypeCallback = (response: string) => void;
+export type GenerateMessageTagTypeCallback = (response: string | FailedResponseType) => void;
 export type SendNodeType = (stanza: BinaryNode, callback: SendNodeTypeCallback) => void;
-export type SendNodeTypeCallback = (response: boolean) => void;
+export type SendNodeTypeCallback = (response: boolean | FailedResponseType) => void;
 export type SignalRepositoryDecryptMessageType = (jid: string, type: "pkmsg" | "msg", ciphertext: Buffer, callback: SignalRepositoryDecryptMessageCallback) => void;
-export type SignalRepositoryDecryptMessageCallback = (response: any) => void;
+export type SignalRepositoryDecryptMessageCallback = (response: Uint8Array | FailedResponseType) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voice-calls-baileys",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Integração de chamadas de voz a biblioteca baileys",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/demo.ts

@@ -9,13 +9,14 @@ async function connectToWhatsApp() {
   const sock = makeWASocket({
     printQRInTerminal: true,
     auth: state,
-    browser: Browsers.macOS('Desktop'),
+    browser: Browsers.windows("UWP"),
+    version: [2, 3000, 1031141796, 257538, 0],
     logger: P({ level: "error" }),
     syncFullHistory: false,
     markOnlineOnConnect: false
   })
 
-  useVoiceCallsBaileys("your token", sock, "close", true)
+  useVoiceCallsBaileys("<Your Wavoip Token>", sock, "<Your Software Name>", "close", true)
 
   sock.ev.on("creds.update", saveCreds);
 

package/src/services/transport.model.ts

@@ -4,18 +4,15 @@ import { ClientToServerEvents, ServerToClientEvents } from "./transport.type";
 
 import { ConnectionState, WAConnectionState, WASocket } from "baileys";
 
-import { Logger } from "pino";
-
 let baileys_connection_state: WAConnectionState = "close";
 
 export const useVoiceCallsBaileys = async (
   wavoip_token: string,
   baileys_sock: WASocket,
+  softwareBase: string,
   status?: WAConnectionState,
   logger?: boolean
 ) => {
-  baileys_connection_state = status ?? "close";
-
   const socket: Socket<ServerToClientEvents, ClientToServerEvents> = io(
     "https://devices.wavoip.com/baileys",
     {
@@ -25,198 +22,100 @@ export const useVoiceCallsBaileys = async (
   );
 
   socket.on("connect", () => {
-    if (logger) console.log("[*] - Wavoip connected", socket.id);
+    if (logger) console.log("[Wavoip] - Connected", socket.id);
 
     socket.emit(
-      "init",
+      "init", 
       baileys_sock.authState.creds.me,
-      baileys_sock.authState.creds.account,
-      baileys_connection_state
+      baileys_sock.authState.creds.account, 
+      status ?? "close", 
+      softwareBase
     );
   });
 
   socket.on("disconnect", () => {
-    if (logger) console.log("[*] - Wavoip disconnect");
+    if (logger) console.log("[Wavoip] - Disconnected");
   });
 
   socket.on("connect_error", (error) => {
-    if (socket.active) {
-      if (logger)
-        console.log(
-          "[*] - Wavoip connection error temporary failure, the socket will automatically try to reconnect",
-          error
-        );
-    } else {
-      if (logger) console.log("[*] - Wavoip connection error", error.message);
-    }
+    if (logger) console.log("[Wavoip] - Connection lost");
   });
 
-  socket.on("onWhatsApp", async (jid, callback) => {
-    try {
-      const response = await baileys_sock.onWhatsApp(jid);
-
-      callback(response);
-
-      if (logger)
-        console.log("[*] Success on call onWhatsApp function", response, jid);
-    } catch (error) {
-      if (logger) console.error("[*] Error on call onWhatsApp function", error);
-    }
+  socket.on("onWhatsApp", (jid, callback) => {
+    baileys_sock.onWhatsApp(jid)
+      .then((response) => callback(response))
+      .catch((error) => {
+        callback({wavoipStatus: "error", result: error});
+        if (logger) console.log("[Wavoip] - Failed to call onWhatsapp, error: ", error)
+      });
   });
 
   socket.on("profilePictureUrl", async (jid, type, timeoutMs, callback) => {
-    try {
-      const response = await baileys_sock.profilePictureUrl(
-        jid,
-        type,
-        timeoutMs
-      );
-
-      callback(response);
-
-      if (logger)
-        console.log("[*] Success on call profilePictureUrl function", response);
-    } catch (error) {
-      if (logger)
-        console.error("[*] Error on call profilePictureUrl function", error);
-    }
+    baileys_sock.profilePictureUrl(jid, type, timeoutMs)
+      .then((response) => callback(response))
+      .catch((error) => {
+        callback({wavoipStatus: "error", result: error});
+        if (logger) console.log("[Wavoip] - Failed to call profilePictureUrl, error: ", error)
+      });
   });
 
   socket.on("assertSessions", async (jids, force, callback) => {
-    try {
-      const response = await baileys_sock.assertSessions(jids, force);
-
-      callback(response);
-
-      if (logger)
-        console.log("[*] Success on call assertSessions function", response);
-    } catch (error) {
-      if (logger)
-        console.error("[*] Error on call assertSessions function", error);
-    }
+    baileys_sock.assertSessions(jids, force)
+      .then((response) => callback(response))
+      .catch((error) => {
+        callback({wavoipStatus: "error", result: error});
+        if (logger) console.log("[Wavoip] - Failed to call assertSessions, error: ", error)
+      });
   });
 
-  socket.on(
-    "createParticipantNodes",
-    async (jids, message, extraAttrs, callback) => {
-      try {
-        const response = await baileys_sock.createParticipantNodes(
-          jids,
-          message,
-          extraAttrs
-        );
-
-        callback(response, true);
-
-        if (logger)
-          console.log(
-            "[*] Success on call createParticipantNodes function",
-            response
-          );
-      } catch (error) {
-        if (logger)
-          console.error(
-            "[*] Error on call createParticipantNodes function",
-            error
-          );
-      }
-    }
-  );
-
-  socket.on(
-    "getUSyncDevices",
-    async (jids, useCache, ignoreZeroDevices, callback) => {
-      try {
-        const response = await baileys_sock.getUSyncDevices(
-          jids,
-          useCache,
-          ignoreZeroDevices
-        );
-
-        callback(response);
-
-        if (logger)
-          console.log("[*] Success on call getUSyncDevices function", response);
-      } catch (error) {
-        if (logger)
-          console.error("[*] Error on call getUSyncDevices function", error);
-      }
-    }
-  );
-
-  socket.on("generateMessageTag", async (callback) => {
-    try {
-      const response = await baileys_sock.generateMessageTag();
-
-      callback(response);
-
-      if (logger)
-        console.log(
-          "[*] Success on call generateMessageTag function",
-          response
-        );
-    } catch (error) {
-      if (logger)
-        console.error("[*] Error on call generateMessageTag function", error);
-    }
+  socket.on("createParticipantNodes", async (jids, message, extraAttrs, callback) => {
+    baileys_sock.createParticipantNodes(jids, message, extraAttrs)
+      .then((response) => callback(response.nodes, response.shouldIncludeDeviceIdentity))
+      .catch((error) => {
+        callback({wavoipStatus: "error", result: error});
+        if (logger) console.log("[Wavoip] - Failed to call createParticipantNodes, error: ", error)
+      });
   });
 
-  socket.on("sendNode", async (stanza, callback) => {
-    try {
-      const response = await baileys_sock.sendNode(stanza);
+  socket.on("getUSyncDevices", async (jids, useCache, ignoreZeroDevices, callback) => {
+    baileys_sock.getUSyncDevices(jids, useCache, ignoreZeroDevices)
+      .then((response) => callback(response))
+      .catch((error) => {
+        callback({wavoipStatus: "error", result: error});
+        if (logger) console.log("[Wavoip] - Failed to call createParticipantNodes, error: ", error)
+      });
+  });
 
-      callback(true);
+  socket.on("generateMessageTag", (callback) => callback(baileys_sock.generateMessageTag()));
 
-      if (logger)
-        console.log("[*] Success on call sendNode function", response);
-    } catch (error) {
-      if (logger) console.error("[*] Error on call sendNode function", error);
-    }
+  socket.on("sendNode", async (stanza, callback) => {
+    baileys_sock.sendNode(stanza)
+      .then((response) => callback(true))
+      .catch((error) => {
+        callback({wavoipStatus: "error", result: error});
+        if (logger) console.log("[Wavoip] - Failed to call createParticipantNodes, error: ", error)
+      });
   });
 
-  socket.on(
-    "signalRepository:decryptMessage",
-    async (jid, type, ciphertext, callback) => {
-      try {
-        const response = await baileys_sock.signalRepository.decryptMessage({
-          jid: jid,
-          type: type,
-          ciphertext: ciphertext,
-        });
-
-        callback(response);
-
-        if (logger)
-          console.log(
-            "[*] Success on call signalRepository:decryptMessage function",
-            response
-          );
-      } catch (error) {
-        if (logger)
-          console.error(
-            "[*] Error on call signalRepository:decryptMessage function",
-            error
-          );
-      }
-    }
-  );
+  socket.on("signalRepository:decryptMessage", async (jid, type, ciphertext, callback) => {
+    baileys_sock.signalRepository.decryptMessage({jid: jid, type: type, ciphertext: ciphertext})
+      .then((response) => callback(response))
+      .catch((error) => {
+        callback({wavoipStatus: "error", result: error});
+        if (logger) console.log("[Wavoip] - Failed to call decryptMessage, error: ", error)
+      });
+  });
 
-  // we only use this connection data to inform the webphone that the device is connected and creeds account to generate e2e whatsapp key for make call packets
-  baileys_sock.ev.on(
-    "connection.update",
-    (update: Partial<ConnectionState>) => {
+  baileys_sock.ev.on("connection.update", (update: Partial<ConnectionState>) => {
       const { connection } = update;
 
       if (connection) {
-        baileys_connection_state = connection;
-        socket
-          .timeout(1000)
-          .emit(
-            "connection.update:status",
-            baileys_sock.authState.creds.me,
-            baileys_sock.authState.creds.account,
-            connection
-          );
+        console.log(connection)
+        socket.timeout(1000).emit("connection.update:status", 
+          baileys_sock.authState.creds.me,
+          baileys_sock.authState.creds.account,
+          connection
+        );
       }
 
       if (update.qr) {
@@ -226,12 +125,10 @@ export const useVoiceCallsBaileys = async (
   );
 
   baileys_sock.ws.on("CB:call", (packet) => {
-    if (logger) console.log("[*] Signling received");
     socket.volatile.timeout(1000).emit("CB:call", packet);
   });
 
   baileys_sock.ws.on("CB:ack,class:call", (packet) => {
-    if (logger) console.log("[*] Signling ack received");
     socket.volatile.timeout(1000).emit("CB:ack,class:call", packet);
   });
 

package/src/services/transport.type.ts

@@ -13,36 +13,41 @@ export interface ServerToClientEvents {
 }
 
 export interface ClientToServerEvents {
-  "init": (me: Contact | undefined, account: proto.IADVSignedDeviceIdentity | undefined, status: WAConnectionState) => void;
+  "init": (me: Contact | undefined, account: proto.IADVSignedDeviceIdentity | undefined, status: WAConnectionState, softwareBase: string) => void;
   "CB:call": (packet: any) => void;
   "CB:ack,class:call": (packet: any) => void;
   "connection.update:status": (me: Contact | undefined, account: proto.IADVSignedDeviceIdentity | undefined, status: WAConnectionState) => void;
   "connection.update:qr": (qr: string) => void;
 }
 
+export type FailedResponseType = {wavoipStatus: string, result: any};
+
 export type onWhatsAppType = (jid: string, callback: onWhatsAppCallback) => void;
 export type onWhatsAppCallback = (response: {
   exists: boolean;
   jid: string;
-}[]) => void;
+}[] | FailedResponseType | undefined) => void;
 
 export type ProfilePictureUrlType = (jid: string, type: "image" | "preview", timeoutMs: number | undefined, callback: ProfilePictureUrlCallback) => void;
-export type ProfilePictureUrlCallback = (response: string | undefined) => void;
+export type ProfilePictureUrlCallback = (response: string | FailedResponseType | undefined) => void;
 
 export type AssertSessionsType = (jids: string[], force: boolean, callback: AssertSessionsCallback) => void;
-export type  AssertSessionsCallback = (response: boolean) => void;
+export type  AssertSessionsCallback = (response: boolean | FailedResponseType) => void;
 
 export type CreateParticipantNodesType = (jids: string[], message: any, extraAttrs: any, callback: CreateParticipantNodesCallback) => void;
-export type CreateParticipantNodesCallback = (nodes: any, shouldIncludeDeviceIdentity: boolean) => void;
+export type CreateParticipantNodesCallback = {
+  (nodes: any, shouldIncludeDeviceIdentity: boolean): void;
+  (response: FailedResponseType): void;
+}
 
 export type GetUSyncDevicesType = (jids: string[], useCache: boolean, ignoreZeroDevices: boolean, callback: GetUSyncDevicesTypeCallback) => void
-export type GetUSyncDevicesTypeCallback = (jids: JidWithDevice[]) => void;
+export type GetUSyncDevicesTypeCallback = (jids: JidWithDevice[] | FailedResponseType) => void;
 
 export type GenerateMessageTagType = (callback: GenerateMessageTagTypeCallback) => void
-export type GenerateMessageTagTypeCallback = (response: string) => void;
+export type GenerateMessageTagTypeCallback = (response: string | FailedResponseType) => void;
 
 export type SendNodeType = (stanza: BinaryNode, callback: SendNodeTypeCallback) => void
-export type SendNodeTypeCallback = (response: boolean) => void;
+export type SendNodeTypeCallback = (response: boolean | FailedResponseType) => void;
 
 export type SignalRepositoryDecryptMessageType = (jid: string, type: "pkmsg" | "msg", ciphertext: Buffer, callback: SignalRepositoryDecryptMessageCallback) => void
-export type SignalRepositoryDecryptMessageCallback = (response: any) => void;
+export type SignalRepositoryDecryptMessageCallback = (response: Uint8Array | FailedResponseType) => void;