@queenanya/baileys 8.2.7-beta → 8.3.1

package/lib/Socket/registration.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRegistrationSocket = void 0;
+exports.registrationParams = registrationParams;
+exports.mobileRegisterCode = mobileRegisterCode;
+exports.mobileRegisterExists = mobileRegisterExists;
+exports.mobileRegister = mobileRegister;
+exports.mobileRegisterEncrypt = mobileRegisterEncrypt;
+exports.mobileRegisterFetch = mobileRegisterFetch;
+/* eslint-disable camelcase */
+const axios_1 = __importDefault(require("axios"));
+const Defaults_1 = require("../Defaults");
+const crypto_1 = require("../Utils/crypto");
+const WABinary_1 = require("../WABinary");
+const business_1 = require("./business");
+function urlencode(str) {
+    return str.replace(/-/g, '%2d').replace(/_/g, '%5f').replace(/~/g, '%7e');
+}
+const validRegistrationOptions = (config) => (config === null || config === void 0 ? void 0 : config.phoneNumberCountryCode) &&
+    config.phoneNumberNationalNumber &&
+    config.phoneNumberMobileCountryCode;
+const makeRegistrationSocket = (config) => {
+    const sock = (0, business_1.makeBusinessSocket)(config);
+    const register = async (code) => {
+        if (!validRegistrationOptions(config.auth.creds.registration)) {
+            throw new Error('please specify the registration options');
+        }
+        const result = await mobileRegister({ ...sock.authState.creds, ...sock.authState.creds.registration, code }, config.options);
+        sock.authState.creds.me = {
+            id: (0, WABinary_1.jidEncode)(result.login, 's.whatsapp.net'),
+            name: '~'
+        };
+        sock.authState.creds.registered = true;
+        sock.ev.emit('creds.update', sock.authState.creds);
+        return result;
+    };
+    const requestRegistrationCode = async (registrationOptions) => {
+        registrationOptions = registrationOptions || config.auth.creds.registration;
+        if (!validRegistrationOptions(registrationOptions)) {
+            throw new Error('Invalid registration options');
+        }
+        sock.authState.creds.registration = registrationOptions;
+        sock.ev.emit('creds.update', sock.authState.creds);
+        return mobileRegisterCode({ ...config.auth.creds, ...registrationOptions }, config.options);
+    };
+    return {
+        ...sock,
+        register,
+        requestRegistrationCode,
+    };
+};
+exports.makeRegistrationSocket = makeRegistrationSocket;
+function convertBufferToUrlHex(buffer) {
+    var id = '';
+    buffer.forEach((x) => {
+        // encode random identity_id buffer as percentage url encoding
+        id += `%${x.toString(16).padStart(2, '0').toLowerCase()}`;
+    });
+    return id;
+}
+function registrationParams(params) {
+    const e_regid = Buffer.alloc(4);
+    e_regid.writeInt32BE(params.registrationId);
+    const e_skey_id = Buffer.alloc(3);
+    e_skey_id.writeInt16BE(params.signedPreKey.keyId);
+    params.phoneNumberCountryCode = params.phoneNumberCountryCode.replace('+', '').trim();
+    params.phoneNumberNationalNumber = params.phoneNumberNationalNumber.replace(/[/-\s)(]/g, '').trim();
+    return {
+        cc: params.phoneNumberCountryCode,
+        in: params.phoneNumberNationalNumber,
+        Rc: '0',
+        lg: 'en',
+        lc: 'GB',
+        mistyped: '6',
+        authkey: Buffer.from(params.noiseKey.public).toString('base64url'),
+        e_regid: e_regid.toString('base64url'),
+        e_keytype: 'BQ',
+        e_ident: Buffer.from(params.signedIdentityKey.public).toString('base64url'),
+        // e_skey_id: e_skey_id.toString('base64url'),
+        e_skey_id: 'AAAA',
+        e_skey_val: Buffer.from(params.signedPreKey.keyPair.public).toString('base64url'),
+        e_skey_sig: Buffer.from(params.signedPreKey.signature).toString('base64url'),
+        fdid: params.phoneId,
+        network_ratio_type: '1',
+        expid: params.deviceId,
+        simnum: '1',
+        hasinrc: '1',
+        pid: Math.floor(Math.random() * 1000).toString(),
+        id: convertBufferToUrlHex(params.identityId),
+        backup_token: convertBufferToUrlHex(params.backupToken),
+        token: (0, crypto_1.md5)(Buffer.concat([Defaults_1.MOBILE_TOKEN, Buffer.from(params.phoneNumberNationalNumber)])).toString('hex'),
+        fraud_checkpoint_code: params.captcha,
+    };
+}
+/**
+ * Requests a registration code for the given phone number.
+ */
+function mobileRegisterCode(params, fetchOptions) {
+    return mobileRegisterFetch('/code', {
+        params: {
+            ...registrationParams(params),
+            mcc: `${params.phoneNumberMobileCountryCode}`.padStart(3, '0'),
+            mnc: `${params.phoneNumberMobileNetworkCode || '001'}`.padStart(3, '0'),
+            sim_mcc: '000',
+            sim_mnc: '000',
+            method: (params === null || params === void 0 ? void 0 : params.method) || 'sms',
+            reason: '',
+            hasav: '1'
+        },
+        ...fetchOptions,
+    });
+}
+function mobileRegisterExists(params, fetchOptions) {
+    return mobileRegisterFetch('/exist', {
+        params: registrationParams(params),
+        ...fetchOptions
+    });
+}
+/**
+ * Registers the phone number on whatsapp with the received OTP code.
+ */
+async function mobileRegister(params, fetchOptions) {
+    //const result = await mobileRegisterFetch(`/reg_onboard_abprop?cc=${params.phoneNumberCountryCode}&in=${params.phoneNumberNationalNumber}&rc=0`)
+    return mobileRegisterFetch('/register', {
+        params: { ...registrationParams(params), code: params.code.replace('-', '') },
+        ...fetchOptions,
+    });
+}
+/**
+ * Encrypts the given string as AEAD aes-256-gcm with the public whatsapp key and a random keypair.
+ */
+function mobileRegisterEncrypt(data) {
+    const keypair = crypto_1.Curve.generateKeyPair();
+    const key = crypto_1.Curve.sharedKey(keypair.private, Defaults_1.REGISTRATION_PUBLIC_KEY);
+    const buffer = (0, crypto_1.aesEncryptGCM)(Buffer.from(data), new Uint8Array(key), Buffer.alloc(12), Buffer.alloc(0));
+    return Buffer.concat([Buffer.from(keypair.public), buffer]).toString('base64url');
+}
+async function mobileRegisterFetch(path, opts = {}) {
+    let url = `${Defaults_1.MOBILE_REGISTRATION_ENDPOINT}${path}`;
+    if (opts.params) {
+        const parameter = [];
+        for (const param in opts.params) {
+            if (opts.params[param] !== null && opts.params[param] !== undefined) {
+                parameter.push(param + '=' + urlencode(opts.params[param]));
+            }
+        }
+        url += `?${parameter.join('&')}`;
+        delete opts.params;
+    }
+    if (!opts.headers) {
+        opts.headers = {};
+    }
+    opts.headers['User-Agent'] = Defaults_1.MOBILE_USERAGENT;
+    const response = await (0, axios_1.default)(url, opts);
+    var json = response.data;
+    if (response.status > 300 || json.reason) {
+        throw json;
+    }
+    if (json.status && !['ok', 'sent'].includes(json.status)) {
+        throw json;
+    }
+    return json;
+}

package/lib/Socket/socket.d.ts

@@ -1,7 +1,6 @@
 import { Boom } from '@hapi/boom';
 import { SocketConfig } from '../Types';
 import { BinaryNode } from '../WABinary';
-import { WebSocketClient } from './Client';
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -10,7 +9,7 @@ import { WebSocketClient } from './Client';
  */
 export declare const makeSocket: (config: SocketConfig) => {
     type: "md";
-    ws: WebSocketClient;
+    ws: any;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): (() => void);
         buffer(): void;

package/lib/Socket/socket.js

@@ -20,14 +20,15 @@ const Client_1 = require("./Client");
 const makeSocket = (config) => {
     var _a, _b;
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository, } = config;
-    const url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
-    if (config.mobile || url.protocol === 'tcp:') {
-        throw new boom_1.Boom('Mobile API is not supported anymore', { statusCode: Types_1.DisconnectReason.loggedOut });
+    let url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
+    config.mobile = config.mobile || url.protocol === 'tcp:';
+    if (config.mobile && url.protocol !== 'tcp:') {
+        url = new url_1.URL(`tcp://${Defaults_1.MOBILE_ENDPOINT}:${Defaults_1.MOBILE_PORT}`);
     }
-    if (url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
+    if (!config.mobile && url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
-    const ws = new Client_1.WebSocketClient(url, config);
+    const ws = config.socket ? config.socket : config.mobile ? new Client_1.MobileSocketClient(url, config) : new Client_1.WebSocketClient(url, config);
     ws.connect();
     const ev = (0, Utils_1.makeEventBuffer)(logger);
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
@@ -35,7 +36,8 @@ const makeSocket = (config) => {
     /** WA noise protocol wrapper */
     const noise = (0, Utils_1.makeNoiseHandler)({
         keyPair: ephemeralKeyPair,
-        NOISE_HEADER: Defaults_1.NOISE_WA_HEADER,
+        NOISE_HEADER: config.mobile ? Defaults_1.MOBILE_NOISE_HEADER : Defaults_1.NOISE_WA_HEADER,
+        mobile: config.mobile,
         logger,
         routingInfo: (_b = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _b === void 0 ? void 0 : _b.routingInfo
     });
@@ -159,7 +161,10 @@ const makeSocket = (config) => {
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = await noise.processHandshake(handshake, creds.noiseKey);
         let node;
-        if (!creds.me) {
+        if (config.mobile) {
+            node = (0, Utils_1.generateMobileNode)(config);
+        }
+        else if (!creds.me) {
             node = (0, Utils_1.generateRegistrationNode)(creds, config);
             logger.info({ node }, 'not logged in, attempting registration...');
         }
@@ -229,11 +234,11 @@ const makeSocket = (config) => {
                 const l0 = frame.tag;
                 const l1 = frame.attrs || {};
                 const l2 = Array.isArray(frame.content) ? (_a = frame.content[0]) === null || _a === void 0 ? void 0 : _a.tag : '';
-                for (const key of Object.keys(l1)) {
+                Object.keys(l1).forEach(key => {
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered;
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered;
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}`, frame) || anyTriggered;
-                }
+                });
                 anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
                 anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
                 if (!anyTriggered && logger.level === 'debug') {
@@ -371,7 +376,7 @@ const makeSocket = (config) => {
         }
         authState.creds.me = {
             id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
-            name: 'ANYA WEB'
+            name: '~'
         };
         ev.emit('creds.update', authState.creds);
         await sendNode({

package/lib/Socket/usync.d.ts

@@ -5,7 +5,7 @@ import { USyncQuery } from '../WAUSync';
 export declare const makeUSyncSocket: (config: SocketConfig) => {
     executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
     type: "md";
-    ws: import("./Client").WebSocketClient;
+    ws: any;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): (() => void);
         buffer(): void;

package/lib/Socket/usync.js

@@ -6,7 +6,7 @@ const WABinary_1 = require("../WABinary");
 const socket_1 = require("./socket");
 const makeUSyncSocket = (config) => {
     const sock = (0, socket_1.makeSocket)(config);
-    const { generateMessageTag, query } = sock;
+    const { generateMessageTag, query, } = sock;
     const executeUSyncQuery = async (usyncQuery) => {
         if (usyncQuery.protocols.length === 0) {
             throw new boom_1.Boom('USyncQuery must have at least one protocol');
@@ -14,13 +14,15 @@ const makeUSyncSocket = (config) => {
         // todo: validate users, throw WARNING on no valid users
         // variable below has only validated users
         const validUsers = usyncQuery.users;
-        const userNodes = validUsers.map(user => {
+        const userNodes = validUsers.map((user) => {
             return {
                 tag: 'user',
                 attrs: {
-                    jid: !user.phone ? user.id : undefined
+                    jid: !user.phone ? user.id : undefined,
                 },
-                content: usyncQuery.protocols.map(a => a.getUserElement(user)).filter(a => a !== null)
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
             };
         });
         const listNode = {
@@ -31,14 +33,14 @@ const makeUSyncSocket = (config) => {
         const queryNode = {
             tag: 'query',
             attrs: {},
-            content: usyncQuery.protocols.map(a => a.getQueryElement())
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
         };
         const iq = {
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
                 type: 'get',
-                xmlns: 'usync'
+                xmlns: 'usync',
             },
             content: [
                 {
@@ -48,18 +50,21 @@ const makeUSyncSocket = (config) => {
                         mode: usyncQuery.mode,
                         sid: generateMessageTag(),
                         last: 'true',
-                        index: '0'
+                        index: '0',
                     },
-                    content: [queryNode, listNode]
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
                 }
-            ]
+            ],
         };
         const result = await query(iq);
         return usyncQuery.parseUSyncQueryResult(result);
     };
     return {
         ...sock,
-        executeUSyncQuery
+        executeUSyncQuery,
     };
 };
 exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Store/make-in-memory-store.js

@@ -191,14 +191,16 @@ exports.default = (config) => {
                         const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid);
                         const list = assertMessageList(jid);
                         list.upsert(msg, 'append');
-                        if (type === 'notify' && !chats.get(jid)) {
-                            ev.emit('chats.upsert', [
-                                {
-                                    id: jid,
-                                    conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
-                                    unreadCount: 1
-                                }
-                            ]);
+                        if (type === 'notify') {
+                            if (!chats.get(jid)) {
+                                ev.emit('chats.upsert', [
+                                    {
+                                        id: jid,
+                                        conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
+                                        unreadCount: 1
+                                    }
+                                ]);
+                            }
                         }
                     }
                     break;

package/lib/Types/Auth.d.ts

@@ -1,4 +1,5 @@
 import type { proto } from '../../WAProto';
+import { RegistrationOptions } from '../Socket/registration';
 import type { Contact } from './Contact';
 import type { MinimalMessage } from './Message';
 export type KeyPair = {
@@ -55,7 +56,12 @@ export type AuthenticationCreds = SignalCreds & {
     /** number of times history & app state has been synced */
     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/lib/Types/Chat.d.ts

@@ -1,18 +1,16 @@
 import type { proto } from '../../WAProto';
 import type { AccountSettings } from './Auth';
-import type { ContactAction } from './Contact';
 import type { BufferedEventData } from './Events';
-import type { LabelActionBody } from './Label';
 import type { ChatLabelAssociationActionBody } from './LabelAssociation';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation';
 import type { MinimalMessage, WAMessageKey } from './Message';
 /** privacy settings in WhatsApp Web */
 export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
+export type WAPrivacyCallValue = 'all' | 'known';
+export type WAPrivacyMessagesValue = 'all' | 'contacts';
 export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
 export type WAPrivacyGroupAddValue = 'all' | 'contacts' | 'contact_blacklist';
 export type WAReadReceiptsValue = 'all' | 'none';
-export type WAPrivacyCallValue = 'all' | 'known';
-export type WAPrivacyMessagesValue = 'all' | 'contacts';
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
 export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
 export declare const ALL_WA_PATCH_NAMES: readonly ["critical_block", "critical_unblock_low", "regular_high", "regular_low", "regular"];
@@ -89,10 +87,6 @@ export type ChatModification = {
 } | {
     delete: true;
     lastMessages: LastMessageList;
-} | {
-    contact: ContactAction | null;
-} | {
-    addLabel: LabelActionBody;
 } | {
     addChatLabel: ChatLabelAssociationActionBody;
 } | {

package/lib/Types/Contact.d.ts

@@ -1,6 +1,10 @@
 export interface Contact {
+    /** ID either in lid or jid format **/
     id: string;
+    /** ID in Lid (anonymous) format (@lid) **/
     lid?: string;
+    /** ID in Phone Number format (@s.whatsapp.net)  **/
+    jid?: string;
     /** name of the contact, you have saved on your WA */
     name?: string;
     /** name of the contact, the contact has set on their own on WA */
@@ -17,8 +21,3 @@ export interface Contact {
     imgUrl?: string | null;
     status?: string;
 }
-export type ContactAction = {
-    fistName: string;
-    fullName: string;
-    saveOnPrimaryAddressbook: boolean;
-};

package/lib/Types/GroupMetadata.d.ts

@@ -3,6 +3,7 @@ export type GroupParticipant = (Contact & {
     isAdmin?: boolean;
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
+    jid?: string;
     lid?: string;
 });
 export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote' | 'modify';
@@ -13,17 +14,17 @@ export interface GroupMetadata {
     /** group uses 'lid' or 'pn' to send messages */
     addressingMode: 'pn' | 'lid';
     owner: string | undefined;
-    onwerPn?: string | undefined;
+    ownerLid?: string | undefined;
     subject: string;
     /** group subject owner */
     subjectOwner?: string;
-    subjectOwnerPn?: string;
+    subjectOwnerLid?: string;
     /** group subject modification date */
     subjectTime?: number;
     creation?: number;
     desc?: string;
     descOwner?: string;
-    descOwnerPn?: string;
+    descOwnerLid?: string;
     descId?: string;
     descTime?: number;
     /** if this group is part of a community, it returns the jid of the community to which it belongs */

package/lib/Types/Label.d.ts

@@ -10,17 +10,6 @@ export interface Label {
     /** WhatsApp has 5 predefined labels (New customer, New order & etc) */
     predefinedId?: string;
 }
-export interface LabelActionBody {
-    id: string;
-    /** Label name */
-    name?: string;
-    /** Label color ID */
-    color?: number;
-    /** Is label has been deleted */
-    deleted?: boolean;
-    /** WhatsApp has 5 predefined labels (New customer, New order & etc) */
-    predefinedId?: number;
-}
 /** WhatsApp has 20 predefined colors */
 export declare enum LabelColor {
     Color1 = 0,

package/lib/Types/Message.d.ts

@@ -13,7 +13,9 @@ export type WAMessageContent = proto.IMessage;
 export type WAContactMessage = proto.Message.IContactMessage;
 export type WAContactsArrayMessage = proto.Message.IContactsArrayMessage;
 export type WAMessageKey = proto.IMessageKey & {
-    lid?: string;
+    senderPn?: string;
+    senderLid?: string;
+    participantLid?: string;
     server_id?: string;
 };
 export type WATextMessage = proto.Message.IExtendedTextMessage;
@@ -22,13 +24,11 @@ export type WALocationMessage = proto.Message.ILocationMessage;
 export type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
 export declare const WAMessageStubType: typeof proto.WebMessageInfo.StubType;
 export declare const WAMessageStatus: typeof proto.WebMessageInfo.Status;
-export type WAMediaPayloadURL = {
+export type WAMediaUpload = Buffer | {
     url: URL | string;
-};
-export type WAMediaPayloadStream = {
+} | {
     stream: Readable;
 };
-export type WAMediaUpload = Buffer | WAMediaPayloadStream | WAMediaPayloadURL;
 /** Set of message types that are supported by the library */
 export type MessageType = keyof proto.Message;
 export type DownloadableMessage = {

package/lib/Types/Socket.d.ts

@@ -31,9 +31,7 @@ export type SocketConfig = {
     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
-    */
+    /** should baileys use the mobile api instead of the multi device api */
     mobile?: boolean;
     /** proxy agent */
     agent?: Agent;
@@ -83,8 +81,6 @@ export type SocketConfig = {
     linkPreviewImageThumbnailWidth: number;
     /** Should Baileys ask the phone for full history, will be received async */
     syncFullHistory: boolean;
-    /** Ignore Message when offline, default is false */
-    ignoreMsgLoading: boolean;
     /** Should baileys fire init queries automatically, default true */
     fireInitQueries: boolean;
     /**
@@ -118,4 +114,6 @@ export type SocketConfig = {
     /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
     cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>;
     makeSignalRepository: (auth: SignalAuthState) => SignalRepository;
+    /** Socket passthrough */
+    socket?: any;
 };

package/lib/Utils/auth-utils.js

@@ -7,6 +7,7 @@ exports.initAuthCreds = exports.addTransactionCapability = void 0;
 exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
 const crypto_1 = require("crypto");
 const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
+const uuid_1 = require("uuid");
 const Defaults_1 = require("../Defaults");
 const crypto_2 = require("./crypto");
 const generics_1 = require("./generics");
@@ -190,7 +191,13 @@ const initAuthCreds = () => {
         accountSettings: {
             unarchiveChats: false
         },
+        // mobile creds
+        deviceId: Buffer.from((0, uuid_1.v4)().replace(/-/g, ''), 'hex').toString('base64url'),
+        phoneId: (0, uuid_1.v4)(),
+        identityId: (0, crypto_1.randomBytes)(20),
         registered: false,
+        backupToken: (0, crypto_1.randomBytes)(20),
+        registration: {},
         pairingCode: undefined,
         lastPropHash: undefined,
         routingInfo: undefined,

package/lib/Utils/chat-utils.d.ts

@@ -28,23 +28,23 @@ export declare const decodeSyncdPatch: (msg: proto.ISyncdPatch, name: WAPatchNam
         };
     };
 }>;
-export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<{}>) => Promise<{
-    critical_block: {
+export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<any>) => Promise<{
+    critical_unblock_low: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
         snapshot?: proto.ISyncdSnapshot;
     };
-    critical_unblock_low: {
+    regular_high: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
         snapshot?: proto.ISyncdSnapshot;
     };
-    regular_high: {
+    regular_low: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
         snapshot?: proto.ISyncdSnapshot;
     };
-    regular_low: {
+    critical_block: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
         snapshot?: proto.ISyncdSnapshot;
@@ -55,13 +55,13 @@ export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosReq
         snapshot?: proto.ISyncdSnapshot;
     };
 }>;
-export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<Buffer<ArrayBuffer>>;
-export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<proto.SyncdMutations>;
+export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<Buffer<ArrayBuffer>>;
+export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<proto.SyncdMutations>;
 export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
     state: LTHashState;
     mutationMap: ChatMutationMap;
 }>;
-export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<{}>, minimumVersionNumber?: number, logger?: ILogger, validateMacs?: boolean) => Promise<{
+export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<any>, minimumVersionNumber?: number, logger?: ILogger, validateMacs?: boolean) => Promise<{
     state: LTHashState;
     mutationMap: ChatMutationMap;
 }>;