zaileys 0.29.7-beta → 0.29.9-beta

package/src/helpers/adapter.ts

@@ -0,0 +1,125 @@
+import { randomBytes, randomUUID } from "crypto";
+import { curve as Curve } from "libsignal";
+import { AppDataSync, Fingerprint, KeyPair, valueReplacer, valueReviver } from "../types/adapter/general";
+
+const curve = Curve as any;
+
+const generateKeyPair = () => {
+  const { pubKey, privKey } = curve.generateKeyPair();
+  return {
+    private: Buffer.from(privKey),
+    public: Buffer.from(pubKey.slice(1)),
+  };
+};
+
+const generateSignalPubKey = (pubKey: Uint8Array) => {
+  return pubKey.length === 33 ? pubKey : Buffer.concat([Buffer.from([5]), pubKey]);
+};
+
+const sign = (privateKey: object, buf: Uint8Array) => {
+  return curve.calculateSignature(privateKey, buf);
+};
+
+const signedKeyPair = (identityKeyPair: KeyPair, keyId: number) => {
+  const preKey = generateKeyPair();
+  const pubKey = generateSignalPubKey(preKey.public);
+  const signature = sign(identityKeyPair.private, pubKey);
+  return { keyPair: preKey, signature, keyId };
+};
+
+const allocate = (str: string) => {
+  let p = str.length;
+
+  if (!p) {
+    return new Uint8Array(1);
+  }
+
+  let n = 0;
+
+  while (--p % 4 > 1 && str.charAt(p) === "=") {
+    ++n;
+  }
+
+  return new Uint8Array(Math.ceil(str.length * 3) / 4 - n).fill(0);
+};
+
+const parseTimestamp = (timestamp: string | number | Long) => {
+  if (typeof timestamp === "string") {
+    return parseInt(timestamp, 10);
+  }
+
+  if (typeof timestamp === "number") {
+    return timestamp;
+  }
+
+  return timestamp;
+};
+
+export const fromObject = (args: AppDataSync) => {
+  const f: Fingerprint = {
+    ...args.fingerprint,
+    deviceIndexes: Array.isArray(args.fingerprint.deviceIndexes) ? args.fingerprint.deviceIndexes : [],
+  };
+
+  const message = {
+    keyData: Array.isArray(args.keyData) ? args.keyData : new Uint8Array(),
+    fingerprint: {
+      rawId: f.rawId || 0,
+      currentIndex: f.rawId || 0,
+      deviceIndexes: f.deviceIndexes,
+    },
+    timestamp: parseTimestamp(args.timestamp),
+  };
+
+  if (typeof args.keyData === "string") {
+    message.keyData = allocate(args.keyData);
+  }
+
+  return message;
+};
+
+export const BufferJSON = {
+  replacer: (_: string, value: valueReplacer) => {
+    if (value?.type === "Buffer" && Array.isArray(value?.data)) {
+      return {
+        type: "Buffer",
+        data: Buffer.from(value?.data).toString("base64"),
+      };
+    }
+    return value;
+  },
+  reviver: (_: string, value: valueReviver) => {
+    if (value?.type === "Buffer") {
+      return Buffer.from(value?.data, "base64");
+    }
+    return value;
+  },
+};
+
+export const initAuthCreds = () => {
+  const identityKey = generateKeyPair();
+  return {
+    noiseKey: generateKeyPair(),
+    pairingEphemeralKeyPair: generateKeyPair(),
+    signedIdentityKey: identityKey,
+    signedPreKey: signedKeyPair(identityKey, 1),
+    registrationId: Uint16Array.from(randomBytes(2))[0] & 16383,
+    advSecretKey: randomBytes(32).toString("base64"),
+    processedHistoryMessages: [],
+    nextPreKeyId: 1,
+    firstUnuploadedPreKeyId: 1,
+    accountSyncCounter: 0,
+    accountSettings: {
+      unarchiveChats: false,
+    },
+    deviceId: Buffer.from(randomUUID().replace(/-/g, ""), "hex").toString("base64url"),
+    phoneId: randomUUID(),
+    identityId: randomBytes(20),
+    backupToken: randomBytes(20),
+    registered: false,
+    registration: {} as never,
+    pairingCode: undefined,
+    lastPropHash: undefined,
+    routingInfo: undefined,
+  };
+};

package/src/helpers/error.ts

@@ -0,0 +1,13 @@
+import { ZodError } from "zod";
+
+export const handleZodError = (error: ZodError) => {
+  const formatted = error.errors.map((err) => ({
+    field: err.path.join("."),
+    message: err.message,
+  }));
+
+  return {
+    status: "error",
+    errors: formatted,
+  };
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+import Client from "./classes/Client";
+export default Client;

package/src/types/adapter/general.ts

@@ -0,0 +1,178 @@
+type Awaitable<T> = T | Promise<T>;
+
+export type AuthAdapterHandlerType = Promise<{
+  state: AuthenticationState;
+  saveCreds: () => Promise<void>;
+  clear: () => Promise<void>;
+  removeCreds: () => Promise<void>
+}>;
+
+type Contact = {
+  id: string;
+  lid?: string;
+  name?: string;
+  notify?: string;
+  verifiedName?: string;
+  imgUrl?: string | null;
+  status?: string;
+};
+
+type Account = {
+  details?: Uint8Array | null;
+  accountSignatureKey?: Uint8Array | null;
+  accountSignature?: Uint8Array | null;
+  deviceSignature?: Uint8Array | null;
+};
+
+type SignedKeyPair = {
+  keyPair: KeyPair;
+  signature: Uint8Array;
+  keyId: number;
+  timestampS?: number;
+};
+
+type ProtocolAddress = {
+  name: string;
+  deviceId: number;
+};
+
+type SignalIdentity = {
+  identifier: ProtocolAddress;
+  identifierKey: Uint8Array;
+};
+
+type LTHashState = {
+  version: number;
+  hash: Buffer;
+  indexValueMap: {
+    [indexMacBase64: string]: { valueMac: Uint8Array | Buffer };
+  };
+};
+
+type SignalCreds = {
+  readonly signedIdentityKey: KeyPair;
+  readonly signedPreKey: SignedKeyPair;
+  readonly registrationId: number;
+};
+
+type AccountSettings = {
+  unarchiveChats: boolean;
+  defaultDisappearingMode?: Pick<any, "ephemeralExpiration" | "ephemeralSettingTimestamp">;
+};
+
+type SignalKeyStore = {
+  get<T extends keyof SignalDataTypeMap>(
+    type: T,
+    ids: string[]
+  ): Awaitable<{
+    [id: string]: SignalDataTypeMap[T];
+  }>;
+  set(data: SignalDataSet): Awaitable<void>;
+  clear?(): Awaitable<void>;
+};
+
+interface RegistrationOptions {
+  phoneNumber?: string;
+  phoneNumberCountryCode: string;
+  phoneNumberNationalNumber: string;
+  phoneNumberMobileCountryCode: string;
+  phoneNumberMobileNetworkCode: string;
+  method?: "sms" | "voice" | "captcha";
+  captcha?: string;
+}
+
+export type SslOptions = {
+  pfx?: string;
+  key?: string | string[] | Buffer | Buffer[];
+  passphrase?: string;
+  cert?: string | string[] | Buffer | Buffer[];
+  ca?: string | string[] | Buffer | Buffer[];
+  crl?: string | string[];
+  ciphers?: string;
+  rejectUnauthorized?: boolean;
+  minVersion?: string;
+  maxVersion?: string;
+  verifyIdentity?: boolean;
+};
+
+export type Fingerprint = {
+  rawId: number;
+  currentIndex: number;
+  deviceIndexes: number[];
+};
+
+export type AppDataSync = {
+  keyData: Uint8Array;
+  fingerprint: Fingerprint;
+  timestamp: Long | number;
+};
+
+export type SignalDataTypeMap = {
+  session: Uint8Array;
+  "pre-key": KeyPair;
+  "sender-key": Uint8Array;
+  "app-state-sync-key": AppDataSync;
+  "app-state-sync-version": LTHashState;
+  "sender-key-memory": {
+    [jid: string]: boolean;
+  };
+};
+
+export type SignalDataSet = {
+  [T in keyof SignalDataTypeMap]?: {
+    [id: string]: SignalDataTypeMap[T] | null;
+  };
+};
+
+export type KeyPair = {
+  public: Uint8Array;
+  private: Uint8Array;
+};
+
+export type sqlData = {
+  constructor: {
+    name: "RowDataPacket";
+  };
+  value?: object[];
+};
+
+export type valueReplacer = {
+  data: number[];
+  type: string;
+};
+
+export type valueReviver = {
+  data: string;
+  type: string;
+};
+
+export type AuthenticationState = {
+  creds: AuthenticationCreds;
+  keys: SignalKeyStore;
+};
+
+export type AuthenticationCreds = SignalCreds & {
+  readonly noiseKey: KeyPair;
+  readonly pairingEphemeralKeyPair: KeyPair;
+  advSecretKey: string;
+  me?: Contact;
+  account?: Account;
+  signalIdentities?: SignalIdentity[];
+  myAppStateKeyId?: string;
+  firstUnuploadedPreKeyId: number;
+  nextPreKeyId: number;
+  lastAccountSyncTimestamp?: number;
+  platform?: string;
+  processedHistoryMessages: Pick<any, "key" | "messageTimestamp">[];
+  accountSyncCounter: number;
+  accountSettings: AccountSettings;
+  deviceId: string;
+  phoneId: string;
+  identityId: Buffer;
+  registered: boolean;
+  backupToken: Buffer;
+  registration: RegistrationOptions;
+  pairingCode: string | undefined;
+  lastPropHash: string | undefined;
+  routingInfo: Buffer | undefined;
+};

package/src/types/classes/client.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+
+export const AdapterDatabaseType = z
+  .object({
+    type: z.enum(["sqlite", "postgresql", "mysql"]).default("sqlite"),
+    connection: z
+      .object({
+        url: z.string().default("./zaileys.db"),
+      })
+      .optional()
+      .default({}),
+  })
+  .optional()
+  .default({});
+
+const ClientClassesBaseType = {
+  prefix: z.string().optional(),
+  ignoreMe: z.boolean().optional().default(true),
+  showLogs: z.boolean().optional().default(true),
+  autoMentions: z.boolean().optional().default(true),
+  autoOnline: z.boolean().optional().default(true),
+  autoRead: z.boolean().optional().default(true),
+  autoRejectCall: z.boolean().optional().default(true),
+  database: AdapterDatabaseType,
+  citation: z
+    .record(z.function().returns(z.union([z.number().array(), z.promise(z.number().array())])))
+    .optional()
+    .transform(async (citation) => {
+      const transform: Record<string, any> = {};
+      if (citation) {
+        for (const key of Object.keys(citation)) {
+          const news = `is${key.charAt(0).toUpperCase() + key.slice(1)}`;
+          const result = await citation[key]();
+          transform[news] = result;
+        }
+      }
+      return transform;
+    }),
+};
+
+const ClientPairingType = z.object({
+  authType: z.literal("pairing"),
+  phoneNumber: z.number(),
+  ...ClientClassesBaseType,
+});
+
+const ClientQRType = z.object({
+  authType: z.literal("qr"),
+  phoneNumber: z.undefined().optional(),
+  ...ClientClassesBaseType,
+});
+
+export const ClientClassesType = z.discriminatedUnion("authType", [ClientPairingType, ClientQRType]);

package/src/types/classes/event.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+const EventConnectionType = z.object({
+  status: z.enum(["connecting", "open", "close"]),
+});
+
+const EventMessagesType = z.object({
+  messages: z.object({
+    remoteJid: z.string(),
+    id: z.string(),
+  }),
+});
+
+const EventCallType = z.object({
+  call: z.object({
+    id: z.string(),
+    from: z.string(),
+    timestamp: z.number(),
+  }),
+});
+
+const EventEnumType = z.enum(["connection", "messages", "call"]);
+export type EventEnumType = z.infer<typeof EventEnumType>;
+
+export type EventCallbackType = {
+  connection: (data: z.infer<typeof EventConnectionType>) => void;
+  messages: (data: z.infer<typeof EventMessagesType>) => void;
+  call: (data: z.infer<typeof EventCallType>) => void;
+};

package/src/types/libsignal.d.ts

@@ -0,0 +1,4 @@
+declare module "libsignal" {
+  export const libsignal: any;
+  export const curve = (...args: any[]): any => {};
+}

package/test/example.ts

@@ -0,0 +1,37 @@
+import Client from "../src";
+
+// the configuration below is the default
+const wa = new Client({
+  prefix: "/", // for command message, example '/'
+  phoneNumber: 6287833764462, // fill bot phone number if auth type is 'pairing'
+  authType: "pairing", // auth type 'pairing' or 'qr'
+  ignoreMe: true, // ignore messages from bot (bot phone number)
+  showLogs: true, // show logs of any chats
+  autoMentions: true, // bot will be auto mentioned if text contains sender number with '@' prefix
+  autoOnline: true, // bot status will be mark online
+  autoRead: true, // auto read message from any chats
+  autoRejectCall: true, // auto reject call if someone call you
+  database: {
+    type: "sqlite", // database type "sqlite" | "postgresql" | "mysql"
+    connection: {
+      url: "./db/zaileys.db", // database url
+    },
+  },
+  citation: {
+    author: async () => {
+      // const res = await fetch...
+      return await [6285136635787];
+    },
+    myGroup: () => [6285136635787],
+  },
+});
+
+wa.on("connection", (ctx) => {
+  // console.log("🚀 ~ example.ts:30 ~ wa.on ~ ctx:", ctx);
+});
+
+wa.on("messages", (ctx) => {
+  console.log("🚀 ~ example.ts:31 ~ wa.on ~ ctx:", ctx);
+});
+
+wa.on("call", () => {});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationDir": "dist",
+    "emitDeclarationOnly": false,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "sourceMap": true
+  },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Zeative Media
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.