@manybot/manybot 5.7.0 → 5.9.0

package/dist/utils/phoneNumber.js

@@ -0,0 +1,83 @@
+/**
+ * src/utils/phoneNumber.ts
+ *
+ * Phone-number normalization built on `libphonenumber-js`. Centralized so
+ * the Baileys adapter, the `whatsmeow` driver, and any future call site
+ * produce a single, consistent shape for the `IContact` returned to
+ * plugins:
+ *
+ *   {
+ *     number:            "+12025550100",     // E.164 with leading "+"
+ *     numberRaw:         "12025550100",      // digits only, no "+"
+ *     numberPretty:      "+1 202 555-0100",  // formatInternational()
+ *     country:           "US",               // ISO 3166-1 alpha-2
+ *     countryCallingCode: "1",               // ITU calling code
+ *   }
+ *
+ * When the input is not a parseable phone number (bot JIDs, group JIDs,
+ * random strings, malformed numbers) every field is `null`. The helper
+ * never throws and never calls the network — it's a pure synchronous
+ * transform over the digits.
+ *
+ * `libphonenumber-js` has many format variants; we pick `formatInternational()`
+ * for `numberPretty` because it's the form most users expect to see in
+ * a chat reply ("+63 938 346-4136") and it preserves the country-code
+ * prefix unambiguously.
+ */
+import parsePhoneNumber from "libphonenumber-js";
+/** All-null {@link ParsedPhoneNumber} — the obvious return value when
+ *  the input isn't a phone number at all. Exported so test code (and
+ *  any consumer that wants to deep-compare) has a stable reference. */
+export const NULL_PHONE = Object.freeze({
+    number: null,
+    numberRaw: null,
+    numberPretty: null,
+    country: null,
+    countryCallingCode: null,
+});
+function isParseable(p) {
+    // libphonenumber-js's `parsePhoneNumberFromString` returns a PhoneNumber
+    // even for garbage input — but `country` is only set when the parser
+    // could pin a country. Use that as the "this is a real phone" signal:
+    // a country-less parse has nothing useful to say about country/CC.
+    return Boolean(p && p.country);
+}
+/**
+ * Parse a phone number into the canonical ManyBot shape. Accepts either
+ * a phone-based JID (`"5511999999999@s.whatsapp.net"`), a `@c.us` legacy
+ * form (`"5511999999999@c.us"`), or a plain digit string. Returns the
+ * all-null `NULL_PHONE` when the input is empty, a non-phone JID (group
+ * `@g.us`, bot meta-AI, status broadcast), or simply not parseable.
+ */
+export function parsePhone(value) {
+    if (!value)
+        return NULL_PHONE;
+    // Strip JID wrapper if present. Anything ending in a non-`@s.whatsapp.net` /
+    // non-`@c.us` server (groups, status, newsletters, bot meta) isn't a phone
+    // number at all — short-circuit to NULL_PHONE before calling the parser.
+    const isJid = value.includes("@");
+    if (isJid) {
+        const server = value.slice(value.indexOf("@") + 1);
+        if (server !== "s.whatsapp.net" && server !== "c.us")
+            return NULL_PHONE;
+    }
+    const digits = value.replace(/\D/g, "");
+    if (!digits)
+        return NULL_PHONE;
+    // Try the raw digit form first (covers the "5511999999999@s.whatsapp.net"
+    // case where the parser knows no default country); the "+"-prefixed form
+    // second (covers "5511999999999" when a default country is supplied by the
+    // caller). Without a country hint libphonenumber-js can't tell a Brazilian
+    // 55-prefix from a Portuguese 55-prefix and returns no country — that's
+    // why the wrapper JID case is the common path.
+    const parsed = parsePhoneNumber(value) ?? parsePhoneNumber("+" + digits);
+    if (!isParseable(parsed))
+        return NULL_PHONE;
+    return {
+        number: parsed.number,
+        numberRaw: digits,
+        numberPretty: parsed.formatInternational(),
+        country: parsed.country ?? null,
+        countryCallingCode: parsed.countryCallingCode ?? null,
+    };
+}

package/dist/utils/phoneNumber.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parsePhone, NULL_PHONE } from "#utils/phoneNumber.js";
+test("parsePhone — US number (NANPA +1)", () => {
+    // Use the 555-0100 reserved-for-fiction range so the example never
+    // collides with a real subscriber anywhere on Earth.
+    const r = parsePhone("+12025550100");
+    assert.equal(r.number, "+12025550100");
+    assert.equal(r.numberRaw, "12025550100");
+    assert.equal(r.country, "US");
+    assert.equal(r.countryCallingCode, "1");
+    assert.match(r.numberPretty, /^\+1 /);
+});
+test("parsePhone — BR number from @s.whatsapp.net JID", () => {
+    const r = parsePhone("5516999999999@s.whatsapp.net");
+    assert.equal(r.number, "+5516999999999");
+    assert.equal(r.numberRaw, "5516999999999");
+    assert.equal(r.country, "BR");
+    assert.equal(r.countryCallingCode, "55");
+    assert.match(r.numberPretty, /^\+55 /);
+});
+test("parsePhone — US number with leading +", () => {
+    const r = parsePhone("+14155552671");
+    assert.equal(r.country, "US");
+    assert.equal(r.countryCallingCode, "1");
+    assert.equal(r.numberRaw, "14155552671");
+});
+test("parsePhone — group JID is not a phone number", () => {
+    // @g.us must NOT be parsed as a phone number, even though its user-part
+    // is digit-only. The wrapper short-circuits to NULL_PHONE.
+    assert.deepEqual(parsePhone("120363402117932687@g.us"), NULL_PHONE);
+});
+test("parsePhone — status/broadcast/newsletter JIDs are not phones", () => {
+    assert.deepEqual(parsePhone("status@broadcast"), NULL_PHONE);
+    assert.deepEqual(parsePhone("0@c.us"), NULL_PHONE);
+});
+test("parsePhone — empty / null / undefined all return NULL_PHONE", () => {
+    assert.deepEqual(parsePhone(""), NULL_PHONE);
+    assert.deepEqual(parsePhone(null), NULL_PHONE);
+    assert.deepEqual(parsePhone(undefined), NULL_PHONE);
+});
+test("parsePhone — unparseable digit string returns NULL_PHONE", () => {
+    // 7 digits with no country hint → libphonenumber-js returns no country
+    // for the raw form and no useful result for the +N form either.
+    assert.deepEqual(parsePhone("1234567"), NULL_PHONE);
+});
+test("parsePhone — accepts the legacy @c.us form (framework internal JID)", () => {
+    // Some code paths still hand us the framework's normalized "@c.us" form
+    // instead of the raw "@s.whatsapp.net" one. Both should parse identically.
+    const wire = parsePhone("5516999999999@s.whatsapp.net");
+    const internal = parsePhone("5516999999999@c.us");
+    assert.deepEqual(internal, wire);
+});

package/package.json

@@ -5,7 +5,7 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "5.7.0",
+  "version": "5.9.0",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {
@@ -25,22 +25,35 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "npm i && tsc && node -e \"fs.mkdirSync('dist/locales', { recursive: true }); fs.cpSync('src/locales', 'dist/locales', { recursive: true }); fs.mkdirSync('dist/drivers/whatsmeow', { recursive: true }); fs.cpSync('src/drivers/whatsmeow/whatsmeow.proto', 'dist/drivers/whatsmeow/whatsmeow.proto');\" && node scripts/build-whatsmeow.mjs",
+    "build": "tsc && node -e \"fs.mkdirSync('dist/locales', { recursive: true }); fs.cpSync('src/locales', 'dist/locales', { recursive: true });\" && npm run build:types",
+    "build:types": "tsc --noEmit -p packages/types/tsconfig.json",
     "start": "node dist/main.js",
-    "typecheck": "tsc --noEmit"
+    "lint": "eslint .",
+    "test": "NODE_ENV=test bash -O globstar -c 'tsx --conditions development --test --experimental-test-coverage src/**/*.test.ts'",
+    "test:integration": "NODE_ENV=test MANYBOT_RUN_WHATSAPP_TESTS=1 bash -O globstar -c 'tsx --conditions development --test src/**/*.integration.test.ts'",
+    "test:integration:local": "NODE_ENV=test MANYBOT_RUN_WHATSAPP_TESTS=1 bash -O globstar -c 'tsx --conditions development --import ./src/main.ts --test src/**/*.integration.test.ts'",
+    "typecheck": "tsc --noEmit",
+    "check": "npm run typecheck && npm run lint && npm run test && npx tsx scripts/check-types-drift.ts"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "@types/nodemailer": "^8.0.1",
+    "eslint": "^10.8.1",
+    "eslint-plugin-import-x": "^4.17.1",
     "tsx": "^4.19.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.67.0"
   },
   "dependencies": {
     "@clack/prompts": "^0.10.1",
     "@grpc/grpc-js": "^1.14.4",
     "@grpc/proto-loader": "^0.7.15",
     "@hapi/boom": "^10.0.1",
-    "@whiskeysockets/baileys": "6.7.24",
+    "@whiskeysockets/baileys": "^7.0.0-rc14",
+    "js-yaml": "^5.2.3",
+    "libphonenumber-js": "^1.13.11",
     "node-cron": "^4.6.0",
     "node-webpmux": "^3.2.1",
     "nodemailer": "^9.0.3",
@@ -49,18 +62,63 @@
     "smol-toml": "^1.7.0"
   },
   "imports": {
-    "#drivers/*": "./dist/drivers/*",
-    "#client/*": "./dist/client/*",
-    "#kernel/*": "./dist/kernel/*",
-    "#manyapi": "./dist/kernel/pluginApi.js",
-    "#settingsdb": "./dist/kernel/settingsDb.js",
-    "#sendguard": "./dist/kernel/sendGuard.js",
-    "#logger": "./dist/logger/logger.js",
-    "#utils/*": "./dist/utils/*",
-    "#i18n": "./dist/i18n/index.js",
-    "#download": "./dist/download/queue.js",
-    "#config": "./dist/config.js",
-    "#main": "./dist/main.js",
-    "#types": "./dist/types.js"
+    "#drivers/*": {
+      "development": "./src/drivers/*",
+      "default": "./dist/drivers/*"
+    },
+    "#client/*": {
+      "development": "./src/client/*",
+      "default": "./dist/client/*"
+    },
+    "#kernel/*": {
+      "development": "./src/kernel/*",
+      "default": "./dist/kernel/*"
+    },
+    "#manyapi": {
+      "development": "./src/kernel/pluginApi.ts",
+      "default": "./dist/kernel/pluginApi.js"
+    },
+    "#settingsdb": {
+      "development": "./src/kernel/settingsDb.ts",
+      "default": "./dist/kernel/settingsDb.js"
+    },
+    "#sendguard": {
+      "development": "./src/kernel/sendGuard.ts",
+      "default": "./dist/kernel/sendGuard.js"
+    },
+    "#logger": {
+      "development": "./src/logger/logger.ts",
+      "default": "./dist/logger/logger.js"
+    },
+    "#utils/*": {
+      "development": "./src/utils/*",
+      "default": "./dist/utils/*"
+    },
+    "#i18n": {
+      "development": "./src/i18n/index.ts",
+      "default": "./dist/i18n/index.js"
+    },
+    "#download": {
+      "development": "./src/download/queue.ts",
+      "default": "./dist/download/queue.js"
+    },
+    "#config": {
+      "development": "./src/config.ts",
+      "default": "./dist/config.js"
+    },
+    "#main": {
+      "development": "./src/main.ts",
+      "default": "./dist/main.js"
+    },
+    "#types": {
+      "development": "./src/types.ts",
+      "default": "./dist/types.js"
+    }
+  },
+  "allowScripts": {
+    "@whiskeysockets/baileys@6.7.24": true,
+    "protobufjs@7.6.5": true,
+    "esbuild@0.28.2": true,
+    "unrs-resolver@1.12.2": true
   }
 }

package/dist/drivers/whatsmeow/client.js

@@ -1,252 +0,0 @@
-import { logger } from "#logger";
-import { CONFIG } from "#config";
-import { t } from "#i18n";
-import * as grpc from "@grpc/grpc-js";
-import * as protoLoader from "@grpc/proto-loader";
-import path from "path";
-import { fileURLToPath } from "node:url";
-import qrcode from "qrcode-terminal";
-/**
- * Whatsmeow gRPC client implementing the WaContract interface.
- *
- * Phase 1 scope: only the send path (sendText) and the
- * verification primitives (getHistory) are fully wired. Every other
- * WaContract method throws "not implemented" — the kernel loads plugins
- * only after `connection.update === "open"`, and a plugin that calls e.g.
- * `groupMetadata` on a whatsmeow-primary bot will surface a clear error
- * to the caller, not a silent no-op.
- *
- * Connects to the address defined in config (default localhost:50051).
- */
-class WhatsmeowClient {
-    name = "whatsmeow";
-    client; // grpc client stub
-    ready = false;
-    handlers = new Map();
-    /**
-     * Resolve the .proto path relative to this compiled module so it works
-     * in ESM (where __dirname doesn't exist), under `node dist/main.js`
-     * (proto is copied to dist/drivers/whatsmeow/whatsmeow.proto by the
-     * build), and under a global npm install (the proto ships alongside
-     * the JS in the package's `dist/` per `files` in package.json). In
-     * dev (`tsx src/main.ts`) the proto already lives next to this source
-     * file, so the same relative path resolves correctly there too.
-     */
-    resolveProtoPath() {
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        return path.resolve(here, "whatsmeow.proto");
-    }
-    loadProto() {
-        const protoPath = this.resolveProtoPath();
-        const packageDef = protoLoader.loadSync(protoPath, {
-            keepCase: true,
-            longs: String,
-            enums: String,
-            defaults: true,
-            oneofs: true,
-        });
-        const grpcObj = grpc.loadPackageDefinition(packageDef);
-        return grpcObj.whatsmeow.WhatsmeowService;
-    }
-    async connect() {
-        const address = CONFIG.drivers.whatsmeow.grpcAddress ?? "localhost:50051";
-        const Service = this.loadProto();
-        this.client = new Service(address, grpc.credentials.createInsecure());
-        // 1. Health check — confirm the gRPC server is up
-        await new Promise((resolve, reject) => {
-            this.client.HealthCheck({}, (err, resp) => {
-                if (err)
-                    return reject(err);
-                this.ready = !!resp?.ready;
-                if (this.ready)
-                    resolve();
-                else
-                    reject(new Error("Whatsmeow service not ready"));
-            });
-        });
-        logger.info("[whatsmeow] gRPC service ready");
-        // 2. Call Connect RPC — initiates WhatsApp auth (QR or reuse existing session)
-        const connectResp = await new Promise((resolve, reject) => {
-            this.client.Connect({}, (err, resp) => {
-                if (err)
-                    return reject(err);
-                resolve(resp);
-            });
-        });
-        const needsAuth = !connectResp.ok;
-        if (needsAuth && connectResp.qrCode) {
-            logger.info(t("system.qrScan"));
-            qrcode.generate(connectResp.qrCode, { small: true });
-        }
-        // 3. Set up auth deferred BEFORE SubscribeEvents to avoid race
-        let authDeferred = null;
-        let authDone = false;
-        const authPromise = needsAuth
-            ? new Promise((resolve, reject) => {
-                authDeferred = { resolve, reject };
-                setTimeout(() => {
-                    if (!authDone) {
-                        authDone = true;
-                        reject(new Error("Whatsmeow auth timeout (2 min)"));
-                    }
-                }, 120_000);
-            })
-            : Promise.resolve();
-        // 4. Open the server-streaming event subscription
-        const stream = this.client.SubscribeEvents({});
-        stream.on("data", (raw) => {
-            // Resolve auth promise when connection opens (QR scanned / session reused)
-            if (!authDone && authDeferred && raw.connState?.state === "open") {
-                authDone = true;
-                authDeferred.resolve();
-                authDeferred = null;
-            }
-            try {
-                if (raw.connState) {
-                    const state = raw.connState.state ?? "connecting";
-                    this.dispatch("connection.update", {
-                        connection: state === "open" ? "open" : state === "close" ? "close" : "connecting",
-                    });
-                }
-                else if (raw.message) {
-                    this.dispatch("messages.upsert", {
-                        messages: [raw.message],
-                        type: "notify",
-                    });
-                }
-            }
-            catch (e) {
-                logger.debug(`[whatsmeow] event dispatch failed: ${e.message}`);
-            }
-        });
-        stream.on("error", (err) => {
-            if (!authDone) {
-                authDone = true;
-                authDeferred?.reject(err);
-                authDeferred = null;
-            }
-            logger.warn(`[whatsmeow] event stream error: ${err.message}`);
-            this.ready = false;
-        });
-        stream.on("end", () => {
-            if (!authDone) {
-                authDone = true;
-                authDeferred?.reject(new Error("Event stream ended before auth completed"));
-                authDeferred = null;
-            }
-            logger.warn(`[whatsmeow] event stream ended`);
-            this.ready = false;
-        });
-        // 5. If not authenticated, wait for connState === "open" from the event stream
-        await authPromise;
-        if (needsAuth) {
-            logger.info("[whatsmeow] authenticated");
-        }
-        this.ready = true;
-    }
-    async disconnect() {
-        if (this.client) {
-            try {
-                await new Promise((resolve) => {
-                    this.client.Disconnect({}, () => resolve());
-                });
-            }
-            catch { }
-            this.client.close();
-        }
-        this.ready = false;
-    }
-    isReady() {
-        return this.ready;
-    }
-    // ── Event fan-out ─────────────────────────────────────────────────────────
-    on(event, handler) {
-        let set = this.handlers.get(event);
-        if (!set) {
-            set = new Set();
-            this.handlers.set(event, set);
-        }
-        set.add(handler);
-        return () => set.delete(handler);
-    }
-    dispatch(event, payload) {
-        const set = this.handlers.get(event);
-        if (!set)
-            return;
-        for (const h of set) {
-            try {
-                h(payload);
-            }
-            catch (e) {
-                logger.debug(`[whatsmeow] handler for "${event}" threw: ${e.message}`);
-            }
-        }
-    }
-    // ── Send ───────────────────────────────────────────────────────────────────
-    // Only sendText is in phase-1 scope. Media fallback is
-    // documented in the interface but explicitly deferred.
-    async sendText(jid, text, opts) {
-        const req = {
-            jid,
-            text,
-            quotedId: opts?.quoted?.id ?? "",
-            mentions: opts?.mentions ?? [],
-        };
-        return new Promise((resolve, reject) => {
-            this.client.SendText(req, (err, resp) => {
-                if (err)
-                    return reject(err);
-                resolve({ id: resp.id, chatId: resp.chatId, timestamp: Number(resp.timestamp) });
-            });
-        });
-    }
-    // ── Verification primitive ─────────────────────────────────────────────────
-    async getHistory(jid, opts) {
-        const req = { jid, limit: opts?.limit ?? 5 };
-        return new Promise((resolve, reject) => {
-            this.client.GetHistory(req, (err, resp) => {
-                if (err)
-                    return reject(err);
-                resolve(resp.messages ?? []);
-            });
-        });
-    }
-    // ── All other WaContract methods: stubbed for now ─────────────────────────
-    // These throw a clear error so a plugin calling them on a whatsmeow-
-    // primary bot fails loudly instead of silently no-op'ing. Coverage will
-    // grow in later phases as the whatsmeow .proto grows.
-    unimplemented(method) {
-        throw new Error(`[whatsmeow] ${method} not implemented in whatsmeow driver yet`);
-    }
-    async resolveLid(_lid) { return null; }
-    async sendImage(_jid, _buffer, _opts) { this.unimplemented("sendImage"); }
-    async sendVideo(_jid, _buffer, _opts) { this.unimplemented("sendVideo"); }
-    async sendAudio(_jid, _buffer, _opts) { this.unimplemented("sendAudio"); }
-    async sendSticker(_jid, _buffer, _opts) { this.unimplemented("sendSticker"); }
-    async sendDocument(_jid, _buffer, _filename, _mimetype, _opts) { this.unimplemented("sendDocument"); }
-    async sendPoll(_jid, _opts) { this.unimplemented("sendPoll"); }
-    async react(_jid, _target, _emoji) { this.unimplemented("react"); }
-    async deleteMessage(_jid, _target, _forEveryone) { this.unimplemented("deleteMessage"); }
-    async editMessage(_jid, _target, _text) { this.unimplemented("editMessage"); }
-    async sendPresenceUpdate(_state, _jid) { this.unimplemented("sendPresenceUpdate"); }
-    async readMessages(_keys) { this.unimplemented("readMessages"); }
-    async onWhatsApp(_jid) { this.unimplemented("onWhatsApp"); }
-    async getBusinessProfile(_jid) { this.unimplemented("getBusinessProfile"); }
-    async profilePictureUrl(_jid) { this.unimplemented("profilePictureUrl"); }
-    async fetchStatus(_jid) { this.unimplemented("fetchStatus"); }
-    async updateBlockStatus(_jid, _action) { this.unimplemented("updateBlockStatus"); }
-    async addOrEditContact(_jid, _info) { this.unimplemented("addOrEditContact"); }
-    async removeContact(_jid) { this.unimplemented("removeContact"); }
-    async groupMetadata(_jid) { this.unimplemented("groupMetadata"); }
-    async groupParticipantsUpdate(_jid, _users, _action) { this.unimplemented("groupParticipantsUpdate"); }
-    async groupUpdateSubject(_jid, _subject) { this.unimplemented("groupUpdateSubject"); }
-    async groupUpdateDescription(_jid, _description) { this.unimplemented("groupUpdateDescription"); }
-    async groupInviteCode(_jid) { this.unimplemented("groupInviteCode"); }
-    async groupRevokeInvite(_jid) { this.unimplemented("groupRevokeInvite"); }
-    async updateProfilePicture(_jid, _buffer) { this.unimplemented("updateProfilePicture"); }
-    async updateProfileName(_name) { this.unimplemented("updateProfileName"); }
-    async updateProfileStatus(_status) { this.unimplemented("updateProfileStatus"); }
-    me() { this.unimplemented("me"); }
-    async downloadMedia(_msg, _opts) { this.unimplemented("downloadMedia"); }
-}
-export const whatsmeowContract = new WhatsmeowClient();

package/dist/drivers/whatsmeow/index.js

@@ -1,79 +0,0 @@
-/**
- * drivers/whatsmeow/index.ts
- *
- * Public surface of the whatsmeow driver:
- *   - whatsmeowContract         : the raw contract (test-only / fallback path)
- *   - wrapWithSupervisor(...)   : returns a contract whose lifecycle
- *                                 methods (connect / disconnect / isReady)
- *                                 are gated on the supervisor state
- *
- * The supervisor is the lifecycle authority for the subprocess; this
- * proxy exists so the DriverManager sees one contract whose `isReady()`
- * never lies — true only when both the gRPC client is up AND the
- * subprocess has answered HealthCheck{ready:true}.
- */
-import { whatsmeowContract } from "./client.js";
-export { whatsmeowContract };
-export { startWhatsmeowSupervisor } from "./supervisor.js";
-/**
- * Wraps a raw whatsmeow contract so its lifecycle methods delegate to
- * the supervisor. Send/event methods still pass through unchanged —
- * the contract already knows how to talk gRPC; the supervisor only
- * owns "is it safe to use right now?".
- */
-export function wrapWithSupervisor(contract, supervisor) {
-    return {
-        name: contract.name,
-        async connect() {
-            await supervisor.whenReady();
-            await contract.connect();
-        },
-        async disconnect() {
-            // Try to stop the subprocess too — disconnecting the contract
-            // alone would leave the Go process running until the bot shuts
-            // down. Idempotent; safe to call multiple times.
-            await Promise.allSettled([
-                contract.disconnect(),
-                supervisor.shutdown(),
-            ]);
-        },
-        isReady: () => supervisor.isReady() && contract.isReady(),
-        on: (...args) => contract.on(...args),
-        resolveLid: contract.resolveLid
-            ? (lid) => contract.resolveLid(lid)
-            : undefined,
-        sendText: (...args) => contract.sendText(...args),
-        sendImage: (...args) => contract.sendImage(...args),
-        sendVideo: (...args) => contract.sendVideo(...args),
-        sendAudio: (...args) => contract.sendAudio(...args),
-        sendSticker: (...args) => contract.sendSticker(...args),
-        sendDocument: (...args) => contract.sendDocument(...args),
-        sendPoll: (...args) => contract.sendPoll(...args),
-        react: (...args) => contract.react(...args),
-        deleteMessage: (...args) => contract.deleteMessage(...args),
-        editMessage: (...args) => contract.editMessage(...args),
-        sendPresenceUpdate: (...args) => contract.sendPresenceUpdate(...args),
-        readMessages: (...args) => contract.readMessages(...args),
-        onWhatsApp: (...args) => contract.onWhatsApp(...args),
-        getBusinessProfile: (...args) => contract.getBusinessProfile(...args),
-        profilePictureUrl: (...args) => contract.profilePictureUrl(...args),
-        fetchStatus: (...args) => contract.fetchStatus(...args),
-        updateBlockStatus: (...args) => contract.updateBlockStatus(...args),
-        addOrEditContact: (...args) => contract.addOrEditContact(...args),
-        removeContact: (...args) => contract.removeContact(...args),
-        groupMetadata: (...args) => contract.groupMetadata(...args),
-        groupParticipantsUpdate: (...args) => contract.groupParticipantsUpdate(...args),
-        groupUpdateSubject: (...args) => contract.groupUpdateSubject(...args),
-        groupUpdateDescription: (...args) => contract.groupUpdateDescription(...args),
-        groupInviteCode: (...args) => contract.groupInviteCode(...args),
-        groupRevokeInvite: (...args) => contract.groupRevokeInvite(...args),
-        updateProfilePicture: (...args) => contract.updateProfilePicture(...args),
-        updateProfileName: (...args) => contract.updateProfileName(...args),
-        updateProfileStatus: (...args) => contract.updateProfileStatus(...args),
-        me: () => contract.me(),
-        downloadMedia: (...args) => contract.downloadMedia(...args),
-        getHistory: contract.getHistory
-            ? (...args) => contract.getHistory(...args)
-            : undefined,
-    };
-}