@d0v3riz/baileys 6.7.19 → 6.7.20

package/lib/Signal/Group/sender-key-message.d.ts

@@ -0,0 +1,18 @@
+import { CiphertextMessage } from './ciphertext-message';
+export declare class SenderKeyMessage extends CiphertextMessage {
+    private readonly SIGNATURE_LENGTH;
+    private readonly messageVersion;
+    private readonly keyId;
+    private readonly iteration;
+    private readonly ciphertext;
+    private readonly signature;
+    private readonly serialized;
+    constructor(keyId?: number | null, iteration?: number | null, ciphertext?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null);
+    getKeyId(): number;
+    getIteration(): number;
+    getCipherText(): Uint8Array;
+    verifySignature(signatureKey: Uint8Array): void;
+    private getSignature;
+    serialize(): Uint8Array;
+    getType(): number;
+}

package/lib/Signal/Group/sender-key-message.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyMessage = void 0;
+const curve_1 = require("libsignal/src/curve");
+const WAProto_1 = require("../../../WAProto");
+const ciphertext_message_1 = require("./ciphertext-message");
+class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
+    constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
+        super();
+        this.SIGNATURE_LENGTH = 64;
+        if (serialized) {
+            const version = serialized[0];
+            const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
+            const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
+            const senderKeyMessage = WAProto_1.proto.SenderKeyMessage.decode(message).toJSON();
+            this.serialized = serialized;
+            this.messageVersion = (version & 0xff) >> 4;
+            this.keyId = senderKeyMessage.id;
+            this.iteration = senderKeyMessage.iteration;
+            this.ciphertext =
+                typeof senderKeyMessage.ciphertext === 'string'
+                    ? Buffer.from(senderKeyMessage.ciphertext, 'base64')
+                    : senderKeyMessage.ciphertext;
+            this.signature = signature;
+        }
+        else {
+            const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
+            const ciphertextBuffer = Buffer.from(ciphertext);
+            const message = WAProto_1.proto.SenderKeyMessage.encode(WAProto_1.proto.SenderKeyMessage.create({
+                id: keyId,
+                iteration: iteration,
+                ciphertext: ciphertextBuffer
+            })).finish();
+            const signature = this.getSignature(signatureKey, Buffer.concat([Buffer.from([version]), message]));
+            this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)]);
+            this.messageVersion = this.CURRENT_VERSION;
+            this.keyId = keyId;
+            this.iteration = iteration;
+            this.ciphertext = ciphertextBuffer;
+            this.signature = signature;
+        }
+    }
+    getKeyId() {
+        return this.keyId;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getCipherText() {
+        return this.ciphertext;
+    }
+    verifySignature(signatureKey) {
+        const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
+        const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
+        const res = (0, curve_1.verifySignature)(signatureKey, part1, part2);
+        if (!res)
+            throw new Error('Invalid signature!');
+    }
+    getSignature(signatureKey, serialized) {
+        return Buffer.from((0, curve_1.calculateSignature)(signatureKey, serialized));
+    }
+    serialize() {
+        return this.serialized;
+    }
+    getType() {
+        return 4;
+    }
+}
+exports.SenderKeyMessage = SenderKeyMessage;

package/lib/Signal/Group/sender-key-name.d.ts

@@ -0,0 +1,17 @@
+interface Sender {
+    id: string;
+    deviceId: number;
+    toString(): string;
+}
+export declare class SenderKeyName {
+    private readonly groupId;
+    private readonly sender;
+    constructor(groupId: string, sender: Sender);
+    getGroupId(): string;
+    getSender(): Sender;
+    serialize(): string;
+    toString(): string;
+    equals(other: SenderKeyName | null): boolean;
+    hashCode(): number;
+}
+export {};

package/lib/Signal/Group/sender-key-name.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyName = void 0;
+function isNull(str) {
+    return str === null || str === '';
+}
+function intValue(num) {
+    const MAX_VALUE = 0x7fffffff;
+    const MIN_VALUE = -0x80000000;
+    if (num > MAX_VALUE || num < MIN_VALUE) {
+        return num & 0xffffffff;
+    }
+    return num;
+}
+function hashCode(strKey) {
+    let hash = 0;
+    if (!isNull(strKey)) {
+        for (let i = 0; i < strKey.length; i++) {
+            hash = hash * 31 + strKey.charCodeAt(i);
+            hash = intValue(hash);
+        }
+    }
+    return hash;
+}
+class SenderKeyName {
+    constructor(groupId, sender) {
+        this.groupId = groupId;
+        this.sender = sender;
+    }
+    getGroupId() {
+        return this.groupId;
+    }
+    getSender() {
+        return this.sender;
+    }
+    serialize() {
+        return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`;
+    }
+    toString() {
+        return this.serialize();
+    }
+    equals(other) {
+        if (other === null)
+            return false;
+        return this.groupId === other.groupId && this.sender.toString() === other.sender.toString();
+    }
+    hashCode() {
+        return hashCode(this.groupId) ^ hashCode(this.sender.toString());
+    }
+}
+exports.SenderKeyName = SenderKeyName;

package/lib/Signal/Group/sender-key-record.d.ts

@@ -0,0 +1,30 @@
+import { SenderKeyState } from './sender-key-state';
+export interface SenderKeyStateStructure {
+    senderKeyId: number;
+    senderChainKey: {
+        iteration: number;
+        seed: Uint8Array;
+    };
+    senderSigningKey: {
+        public: Uint8Array;
+        private?: Uint8Array;
+    };
+    senderMessageKeys: Array<{
+        iteration: number;
+        seed: Uint8Array;
+    }>;
+}
+export declare class SenderKeyRecord {
+    private readonly MAX_STATES;
+    private readonly senderKeyStates;
+    constructor(serialized?: SenderKeyStateStructure[]);
+    isEmpty(): boolean;
+    getSenderKeyState(keyId?: number): SenderKeyState | undefined;
+    addSenderKeyState(id: number, iteration: number, chainKey: Uint8Array, signatureKey: Uint8Array): void;
+    setSenderKeyState(id: number, iteration: number, chainKey: Uint8Array, keyPair: {
+        public: Uint8Array;
+        private: Uint8Array;
+    }): void;
+    serialize(): SenderKeyStateStructure[];
+    static deserialize(data: Uint8Array | string | SenderKeyStateStructure[]): SenderKeyRecord;
+}

package/lib/Signal/Group/sender-key-record.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyRecord = void 0;
+const generics_1 = require("../../Utils/generics");
+const sender_key_state_1 = require("./sender-key-state");
+class SenderKeyRecord {
+    constructor(serialized) {
+        this.MAX_STATES = 5;
+        this.senderKeyStates = [];
+        if (serialized) {
+            for (const structure of serialized) {
+                this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(null, null, null, null, null, null, structure));
+            }
+        }
+    }
+    isEmpty() {
+        return this.senderKeyStates.length === 0;
+    }
+    getSenderKeyState(keyId) {
+        if (keyId === undefined && this.senderKeyStates.length) {
+            return this.senderKeyStates[this.senderKeyStates.length - 1];
+        }
+        return this.senderKeyStates.find(state => state.getKeyId() === keyId);
+    }
+    addSenderKeyState(id, iteration, chainKey, signatureKey) {
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, null, signatureKey));
+        if (this.senderKeyStates.length > this.MAX_STATES) {
+            this.senderKeyStates.shift();
+        }
+    }
+    setSenderKeyState(id, iteration, chainKey, keyPair) {
+        this.senderKeyStates.length = 0;
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, keyPair));
+    }
+    serialize() {
+        return this.senderKeyStates.map(state => state.getStructure());
+    }
+    static deserialize(data) {
+        let parsed;
+        if (typeof data === 'string') {
+            parsed = JSON.parse(data, generics_1.BufferJSON.reviver);
+        }
+        else if (data instanceof Uint8Array) {
+            const str = Buffer.from(data).toString('utf-8');
+            parsed = JSON.parse(str, generics_1.BufferJSON.reviver);
+        }
+        else {
+            parsed = data;
+        }
+        return new SenderKeyRecord(parsed);
+    }
+}
+exports.SenderKeyRecord = SenderKeyRecord;

package/lib/Signal/Group/sender-key-state.d.ts

@@ -0,0 +1,38 @@
+import { SenderChainKey } from './sender-chain-key';
+import { SenderMessageKey } from './sender-message-key';
+interface SenderChainKeyStructure {
+    iteration: number;
+    seed: Uint8Array;
+}
+interface SenderSigningKeyStructure {
+    public: Uint8Array;
+    private?: Uint8Array;
+}
+interface SenderMessageKeyStructure {
+    iteration: number;
+    seed: Uint8Array;
+}
+interface SenderKeyStateStructure {
+    senderKeyId: number;
+    senderChainKey: SenderChainKeyStructure;
+    senderSigningKey: SenderSigningKeyStructure;
+    senderMessageKeys: SenderMessageKeyStructure[];
+}
+export declare class SenderKeyState {
+    private readonly MAX_MESSAGE_KEYS;
+    private readonly senderKeyStateStructure;
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKeyPair?: {
+        public: Uint8Array;
+        private: Uint8Array;
+    } | null, signatureKeyPublic?: Uint8Array | null, signatureKeyPrivate?: Uint8Array | null, senderKeyStateStructure?: SenderKeyStateStructure | null);
+    getKeyId(): number;
+    getSenderChainKey(): SenderChainKey;
+    setSenderChainKey(chainKey: SenderChainKey): void;
+    getSigningKeyPublic(): Buffer;
+    getSigningKeyPrivate(): Buffer | undefined;
+    hasSenderMessageKey(iteration: number): boolean;
+    addSenderMessageKey(senderMessageKey: SenderMessageKey): void;
+    removeSenderMessageKey(iteration: number): SenderMessageKey | null;
+    getStructure(): SenderKeyStateStructure;
+}
+export {};

package/lib/Signal/Group/sender-key-state.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyState = void 0;
+const sender_chain_key_1 = require("./sender-chain-key");
+const sender_message_key_1 = require("./sender-message-key");
+class SenderKeyState {
+    constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
+        this.MAX_MESSAGE_KEYS = 2000;
+        if (senderKeyStateStructure) {
+            this.senderKeyStateStructure = senderKeyStateStructure;
+        }
+        else {
+            if (signatureKeyPair) {
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
+            }
+            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
+            const senderChainKeyStructure = {
+                iteration: iteration || 0,
+                seed: chainKey || Buffer.alloc(0)
+            };
+            const signingKeyStructure = {
+                public: typeof signatureKeyPublic === 'string'
+                    ? Buffer.from(signatureKeyPublic, 'base64')
+                    : signatureKeyPublic || Buffer.alloc(0)
+            };
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ? Buffer.from(signatureKeyPrivate, 'base64') : signatureKeyPrivate;
+            }
+            this.senderKeyStateStructure = {
+                senderKeyId: id || 0,
+                senderChainKey: senderChainKeyStructure,
+                senderSigningKey: signingKeyStructure,
+                senderMessageKeys: []
+            };
+        }
+    }
+    getKeyId() {
+        return this.senderKeyStateStructure.senderKeyId;
+    }
+    getSenderChainKey() {
+        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
+    }
+    setSenderChainKey(chainKey) {
+        this.senderKeyStateStructure.senderChainKey = {
+            iteration: chainKey.getIteration(),
+            seed: chainKey.getSeed()
+        };
+    }
+    getSigningKeyPublic() {
+        const publicKey = this.senderKeyStateStructure.senderSigningKey.public;
+        if (publicKey instanceof Buffer) {
+            return publicKey;
+        }
+        else if (typeof publicKey === 'string') {
+            return Buffer.from(publicKey, 'base64');
+        }
+        return Buffer.from(publicKey || []);
+    }
+    getSigningKeyPrivate() {
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+        if (!privateKey) {
+            return undefined;
+        }
+        if (privateKey instanceof Buffer) {
+            return privateKey;
+        }
+        else if (typeof privateKey === 'string') {
+            return Buffer.from(privateKey, 'base64');
+        }
+        return Buffer.from(privateKey || []);
+    }
+    hasSenderMessageKey(iteration) {
+        return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration);
+    }
+    addSenderMessageKey(senderMessageKey) {
+        this.senderKeyStateStructure.senderMessageKeys.push({
+            iteration: senderMessageKey.getIteration(),
+            seed: senderMessageKey.getSeed()
+        });
+        if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+            this.senderKeyStateStructure.senderMessageKeys.shift();
+        }
+    }
+    removeSenderMessageKey(iteration) {
+        const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration);
+        if (index !== -1) {
+            const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
+            this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
+            return new sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed);
+        }
+        return null;
+    }
+    getStructure() {
+        return this.senderKeyStateStructure;
+    }
+}
+exports.SenderKeyState = SenderKeyState;

package/lib/Signal/Group/sender-message-key.d.ts

@@ -0,0 +1,11 @@
+export declare class SenderMessageKey {
+    private readonly iteration;
+    private readonly iv;
+    private readonly cipherKey;
+    private readonly seed;
+    constructor(iteration: number, seed: Uint8Array);
+    getIteration(): number;
+    getIv(): Uint8Array;
+    getCipherKey(): Uint8Array;
+    getSeed(): Uint8Array;
+}

package/{WASignalGroup/sender_message_key.js → lib/Signal/Group/sender-message-key.js}

@@ -1,39 +1,29 @@
-const { deriveSecrets } = require('libsignal/src/crypto');
-class SenderMessageKey {
-    iteration = 0;
-
-    iv = Buffer.alloc(0);
-
-    cipherKey = Buffer.alloc(0);
-
-    seed = Buffer.alloc(0);
-
-    constructor(iteration, seed) {
-        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
-        const keys = new Uint8Array(32);
-        keys.set(new Uint8Array(derivative[0].slice(16)));
-        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
-        this.iv = Buffer.from(derivative[0].slice(0, 16));
-        this.cipherKey = Buffer.from(keys.buffer);
-
-        this.iteration = iteration;
-        this.seed = seed;
-    }
-
-    getIteration() {
-        return this.iteration;
-    }
-
-    getIv() {
-        return this.iv;
-    }
-
-    getCipherKey() {
-        return this.cipherKey;
-    }
-
-    getSeed() {
-        return this.seed;
-    }
-}
-module.exports = SenderMessageKey;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderMessageKey = void 0;
+const crypto_1 = require("libsignal/src/crypto");
+class SenderMessageKey {
+    constructor(iteration, seed) {
+        const derivative = (0, crypto_1.deriveSecrets)(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
+        const keys = new Uint8Array(32);
+        keys.set(new Uint8Array(derivative[0].slice(16)));
+        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
+        this.iv = Buffer.from(derivative[0].slice(0, 16));
+        this.cipherKey = Buffer.from(keys.buffer);
+        this.iteration = iteration;
+        this.seed = seed;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getIv() {
+        return this.iv;
+    }
+    getCipherKey() {
+        return this.cipherKey;
+    }
+    getSeed() {
+        return this.seed;
+    }
+}
+exports.SenderMessageKey = SenderMessageKey;

package/lib/Signal/libsignal.js

@@ -35,24 +35,30 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLibSignalRepository = makeLibSignalRepository;
 const libsignal = __importStar(require("libsignal"));
-const WASignalGroup_1 = require("../../WASignalGroup");
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
+const sender_key_name_1 = require("./Group/sender-key-name");
+const sender_key_record_1 = require("./Group/sender-key-record");
+const Group_1 = require("./Group");
 function makeLibSignalRepository(auth) {
     const storage = signalStorage(auth);
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
-            const cipher = new WASignalGroup_1.GroupCipher(storage, senderName);
+            const cipher = new Group_1.GroupCipher(storage, senderName);
             return cipher.decrypt(msg);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message');
+            }
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
-            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
             await builder.process(senderName, senderMsg);
         },
@@ -67,6 +73,8 @@ function makeLibSignalRepository(auth) {
                 case 'msg':
                     result = await session.decryptWhisperMessage(ciphertext);
                     break;
+                default:
+                    throw new Error(`Unknown message type: ${type}`);
             }
             return result;
         },
@@ -79,17 +87,18 @@ function makeLibSignalRepository(auth) {
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
-            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
             const senderKeyDistributionMessage = await builder.create(senderName);
-            const session = new WASignalGroup_1.GroupCipher(storage, senderName);
+            const session = new Group_1.GroupCipher(storage, senderName);
             const ciphertext = await session.encrypt(data);
             return {
                 ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
             };
         },
         async injectE2ESession({ jid, session }) {
@@ -98,7 +107,7 @@ function makeLibSignalRepository(auth) {
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
-        },
+        }
     };
 }
 const jidToSignalProtocolAddress = (jid) => {
@@ -106,7 +115,7 @@ const jidToSignalProtocolAddress = (jid) => {
     return new libsignal.ProtocolAddress(user, device || 0);
 };
 const jidToSignalSenderKeyName = (group, user) => {
-    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString();
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
 function signalStorage({ creds, keys }) {
     return {
@@ -117,7 +126,7 @@ function signalStorage({ creds, keys }) {
             }
         },
         storeSession: async (id, session) => {
-            await keys.set({ 'session': { [id]: session.serialize() } });
+            await keys.set({ session: { [id]: session.serialize() } });
         },
         isTrustedIdentity: () => {
             return true;
@@ -140,21 +149,25 @@ function signalStorage({ creds, keys }) {
                 pubKey: Buffer.from(key.keyPair.public)
             };
         },
-        loadSenderKey: async (keyId) => {
+        loadSenderKey: async (senderKeyName) => {
+            const keyId = senderKeyName.toString();
             const { [keyId]: key } = await keys.get('sender-key', [keyId]);
             if (key) {
-                return new WASignalGroup_1.SenderKeyRecord(key);
+                return sender_key_record_1.SenderKeyRecord.deserialize(key);
             }
+            return new sender_key_record_1.SenderKeyRecord();
         },
-        storeSenderKey: async (keyId, key) => {
-            await keys.set({ 'sender-key': { [keyId]: key.serialize() } });
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString();
+            const serialized = JSON.stringify(key.serialize());
+            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } });
         },
-        getOurRegistrationId: () => (creds.registrationId),
+        getOurRegistrationId: () => creds.registrationId,
         getOurIdentity: () => {
             const { signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
             };
         }
     };

package/lib/Socket/Client/websocket.js

@@ -38,7 +38,7 @@ class WebSocketClient extends types_1.AbstractSocketClient {
             headers: (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers,
             handshakeTimeout: this.config.connectTimeoutMs,
             timeout: this.config.connectTimeoutMs,
-            agent: this.config.agent,
+            agent: this.config.agent
         });
         this.socket.setMaxListeners(0);
         const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];

package/lib/Socket/business.d.ts

@@ -60,7 +60,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     groupRevokeInvite: (jid: string) => Promise<string | undefined>;
     groupAcceptInvite: (code: string) => Promise<string | undefined>;
     groupRevokeInviteV4: (groupJid: string, invitedJid: string) => Promise<boolean>;
-    groupAcceptInviteV4: (key: string | import("../Types").WAProto.IMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<any>;
+    groupAcceptInviteV4: (key: string | import("../Types").WAMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<any>;
     groupGetInviteInfo: (code: string) => Promise<import("../Types").GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
     groupSettingUpdate: (jid: string, setting: "announcement" | "not_announcement" | "locked" | "unlocked") => Promise<void>;
@@ -101,7 +101,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyGroupAddValue) => Promise<void>;
     updateDefaultDisappearingMode: (duration: number) => Promise<void>;
     getBusinessProfile: (jid: string) => Promise<import("../Types").WABusinessProfile | void>;
-    resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    resyncAppState: (collections: readonly ("critical_unblock_low" | "regular_high" | "regular_low" | "critical_block" | "regular")[], isInitialSync: boolean) => Promise<void>;
     chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
     cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => Promise<void>;
     addLabel: (jid: string, labels: import("../Types/Label").LabelActionBody) => Promise<void>;
@@ -117,9 +117,9 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
-        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): (() => void);
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;
-        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): (...args: A) => Promise<T>;
         flush(force?: boolean): boolean;
         isBuffering(): boolean;
     };
@@ -140,7 +140,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     onUnexpectedError: (err: Error | import("@hapi/boom").Boom, msg: string) => void;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
-    requestPairingCode: (phoneNumber: string) => Promise<string>;
+    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
 };