@rexxhayanasi/elaina-baileys 1.2.1-rc.5 → 1.2.1-rc.6

package/lib/Signal/Group/keyhelper.js

@@ -1,22 +1,20 @@
 "use strict";
-/**
- * Signal Group Key Helper
- * Helper functions to generate sender keys and signing keys safely.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-
 var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
     Object.defineProperty(o, "default", { enumerable: true, value: v });
 }) : function(o, v) {
     o["default"] = v;
 });
-
 var __importStar = (this && this.__importStar) || (function () {
     var ownKeys = function(o) {
         ownKeys = Object.getOwnPropertyNames || function (o) {
@@ -34,55 +32,24 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSenderKey = generateSenderKey;
 exports.generateSenderKeyId = generateSenderKeyId;
 exports.generateSenderSigningKey = generateSenderSigningKey;
-
 const nodeCrypto = __importStar(require("crypto"));
-const curve_1 = require("libsignal/src/curve"); 
-
-/**
- * Generates a random 32-byte Sender Key.
- * @returns {Buffer} The generated key.
- */
+const curve_1 = require("libsignal/src/curve");
 function generateSenderKey() {
-    const key = nodeCrypto.randomBytes(32);
-    if (key.length !== 32) {
-        throw new Error("Failed to generate a valid 32-byte Sender Key");
-    }
-    return key;
+    return nodeCrypto.randomBytes(32);
 }
-
-/**
- * Generates a random Sender Key ID.
- * @returns {number} The generated Key ID.
- */
 function generateSenderKeyId() {
-    const id = nodeCrypto.randomInt(2147483647);
-    if (!id || typeof id !== 'number') {
-        throw new Error("Failed to generate Sender Key ID");
-    }
-    return id;
+    return nodeCrypto.randomInt(2147483647);
 }
-
-/**
- * Generates a Sender Signing Key Pair.
- * Uses libsignal's curve implementation.
- * @param {Object} [key] Optional existing key pair.
- * @returns {Object} The key pair (public/private).
- */
 function generateSenderSigningKey(key) {
     if (!key) {
         key = (0, curve_1.generateKeyPair)();
     }
-
-    if (!key || !key.pubKey || !key.privKey) {
-        throw new Error("Invalid KeyPair generated from Curve");
-    }
     return {
-        public: key.pubKey, 
-        private: key.privKey
+        public: Buffer.from(key.pubKey),
+        private: Buffer.from(key.privKey)
     };
 }

package/lib/Socket/communities.js

@@ -0,0 +1,441 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCommunityMetadata = exports.makeCommunitiesSocket = void 0;
+const WAProto_1 = require("../../WAProto/index.js");
+const Types_1 = require("../Types");
+const Utils_1 = require("../Utils");
+const logger_1 = __importDefault(require("../Utils/logger"));
+const WABinary_1 = require("../WABinary");
+const business_1 = require("./business");
+
+const makeCommunitiesSocket = (config) => {
+    const sock = (0, business_1.makeBusinessSocket)(config);
+    const { authState, ev, query, upsertMessage } = sock;
+    const communityQuery = async (jid, type, content) => query({
+        tag: 'iq',
+        attrs: {
+            type,
+            xmlns: 'w:g2',
+            to: jid
+        },
+        content
+    });
+    const communityMetadata = async (jid) => {
+        const result = await communityQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+        return (0, exports.extractCommunityMetadata)(result);
+    };
+    const communityFetchAllParticipating = async () => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: '@g.us',
+                xmlns: 'w:g2',
+                type: 'get'
+            },
+            content: [
+                {
+                    tag: 'participating',
+                    attrs: {},
+                    content: [
+                        { tag: 'participants', attrs: {} },
+                        { tag: 'description', attrs: {} }
+                    ]
+                }
+            ]
+        });
+        const data = {};
+        const communitiesChild = (0, WABinary_1.getBinaryNodeChild)(result, 'communities');
+        if (communitiesChild) {
+            const communities = (0, WABinary_1.getBinaryNodeChildren)(communitiesChild, 'community');
+            for (const communityNode of communities) {
+                const meta = (0, exports.extractCommunityMetadata)({
+                    tag: 'result',
+                    attrs: {},
+                    content: [communityNode]
+                });
+                data[meta.id] = meta;
+            }
+        }
+        sock.ev.emit('groups.update', Object.values(data));
+        return data;
+    };
+    async function parseGroupResult(node) {
+        logger_1.default.info({ node }, 'parseGroupResult');
+        const groupNode = (0, WABinary_1.getBinaryNodeChild)(node, 'group');
+        if (groupNode) {
+            try {
+                logger_1.default.info({ groupNode }, 'groupNode');
+                const metadata = await sock.groupMetadata(`${groupNode.attrs.id}@g.us`);
+                return metadata ? metadata : Optional.empty();
+            }
+            catch (error) {
+                console.error('Error parsing group metadata:', error);
+                return Optional.empty();
+            }
+        }
+        return Optional.empty();
+    }
+    const Optional = {
+        empty: () => null,
+        of: (value) => (value !== null ? { value } : null)
+    };
+    sock.ws.on('CB:ib,,dirty', async (node) => {
+        const { attrs } = (0, WABinary_1.getBinaryNodeChild)(node, 'dirty');
+        if (attrs.type !== 'communities') {
+            return;
+        }
+        await communityFetchAllParticipating();
+        await sock.cleanDirtyBits('groups');
+    });
+    return {
+        ...sock,
+        communityMetadata,
+        communityCreate: async (subject, body) => {
+            const descriptionId = (0, Utils_1.generateMessageID)().substring(0, 12);
+            const result = await communityQuery('@g.us', 'set', [
+                {
+                    tag: 'create',
+                    attrs: { subject },
+                    content: [
+                        {
+                            tag: 'description',
+                            attrs: { id: descriptionId },
+                            content: [
+                                {
+                                    tag: 'body',
+                                    attrs: {},
+                                    content: Buffer.from(body || '', 'utf-8')
+                                }
+                            ]
+                        },
+                        {
+                            tag: 'parent',
+                            attrs: { default_membership_approval_mode: 'request_required' }
+                        },
+                        {
+                            tag: 'allow_non_admin_sub_group_creation',
+                            attrs: {}
+                        },
+                        {
+                            tag: 'create_general_chat',
+                            attrs: {}
+                        }
+                    ]
+                }
+            ]);
+            return await parseGroupResult(result);
+        },
+        communityCreateGroup: async (subject, participants, parentCommunityJid) => {
+            const key = (0, Utils_1.generateMessageIDV2)();
+            const result = await communityQuery('@g.us', 'set', [
+                {
+                    tag: 'create',
+                    attrs: {
+                        subject,
+                        key
+                    },
+                    content: [
+                        ...participants.map(jid => ({
+                            tag: 'participant',
+                            attrs: { jid }
+                        })),
+                        { tag: 'linked_parent', attrs: { jid: parentCommunityJid } }
+                    ]
+                }
+            ]);
+            return await parseGroupResult(result);
+        },
+        communityLeave: async (id) => {
+            await communityQuery('@g.us', 'set', [
+                {
+                    tag: 'leave',
+                    attrs: {},
+                    content: [{ tag: 'community', attrs: { id } }]
+                }
+            ]);
+        },
+        communityUpdateSubject: async (jid, subject) => {
+            await communityQuery(jid, 'set', [
+                {
+                    tag: 'subject',
+                    attrs: {},
+                    content: Buffer.from(subject, 'utf-8')
+                }
+            ]);
+        },
+        communityLinkGroup: async (groupJid, parentCommunityJid) => {
+            await communityQuery(parentCommunityJid, 'set', [
+                {
+                    tag: 'links',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'link',
+                            attrs: { link_type: 'sub_group' },
+                            content: [{ tag: 'group', attrs: { jid: groupJid } }]
+                        }
+                    ]
+                }
+            ]);
+        },
+        communityUnlinkGroup: async (groupJid, parentCommunityJid) => {
+            await communityQuery(parentCommunityJid, 'set', [
+                {
+                    tag: 'unlink',
+                    attrs: { unlink_type: 'sub_group' },
+                    content: [{ tag: 'group', attrs: { jid: groupJid } }]
+                }
+            ]);
+        },
+        communityFetchLinkedGroups: async (jid) => {
+            let communityJid = jid;
+            let isCommunity = false;
+            // Try to determine if it is a subgroup or a community
+            const metadata = await sock.groupMetadata(jid);
+            if (metadata.linkedParent) {
+                // It is a subgroup, get the community jid
+                communityJid = metadata.linkedParent;
+            }
+            else {
+                // It is a community
+                isCommunity = true;
+            }
+            // Fetch all subgroups of the community
+            const result = await communityQuery(communityJid, 'get', [{ tag: 'sub_groups', attrs: {} }]);
+            const linkedGroupsData = [];
+            const subGroupsNode = (0, WABinary_1.getBinaryNodeChild)(result, 'sub_groups');
+            if (subGroupsNode) {
+                const groupNodes = (0, WABinary_1.getBinaryNodeChildren)(subGroupsNode, 'group');
+                for (const groupNode of groupNodes) {
+                    linkedGroupsData.push({
+                        id: groupNode.attrs.id ? (0, WABinary_1.jidEncode)(groupNode.attrs.id, 'g.us') : undefined,
+                        subject: groupNode.attrs.subject || '',
+                        creation: groupNode.attrs.creation ? Number(groupNode.attrs.creation) : undefined,
+                        owner: groupNode.attrs.creator ? (0, WABinary_1.jidNormalizedUser)(groupNode.attrs.creator) : undefined,
+                        size: groupNode.attrs.size ? Number(groupNode.attrs.size) : undefined
+                    });
+                }
+            }
+            return {
+                communityJid,
+                isCommunity,
+                linkedGroups: linkedGroupsData
+            };
+        },
+        communityRequestParticipantsList: async (jid) => {
+            const result = await communityQuery(jid, 'get', [
+                {
+                    tag: 'membership_approval_requests',
+                    attrs: {}
+                }
+            ]);
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_approval_requests');
+            const participants = (0, WABinary_1.getBinaryNodeChildren)(node, 'membership_approval_request');
+            return participants.map(v => v.attrs);
+        },
+        communityRequestParticipantsUpdate: async (jid, participants, action) => {
+            const result = await communityQuery(jid, 'set', [
+                {
+                    tag: 'membership_requests_action',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: action,
+                            attrs: {},
+                            content: participants.map(jid => ({
+                                tag: 'participant',
+                                attrs: { jid }
+                            }))
+                        }
+                    ]
+                }
+            ]);
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, 'membership_requests_action');
+            const nodeAction = (0, WABinary_1.getBinaryNodeChild)(node, action);
+            const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(nodeAction, 'participant');
+            return participantsAffected.map(p => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid };
+            });
+        },
+        communityParticipantsUpdate: async (jid, participants, action) => {
+            const result = await communityQuery(jid, 'set', [
+                {
+                    tag: action,
+                    attrs: action === 'remove' ? { linked_groups: 'true' } : {},
+                    content: participants.map(jid => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ]);
+            const node = (0, WABinary_1.getBinaryNodeChild)(result, action);
+            const participantsAffected = (0, WABinary_1.getBinaryNodeChildren)(node, 'participant');
+            return participantsAffected.map(p => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p };
+            });
+        },
+        communityUpdateDescription: async (jid, description) => {
+            const metadata = await communityMetadata(jid);
+            const prev = metadata.descId ?? null;
+            await communityQuery(jid, 'set', [
+                {
+                    tag: 'description',
+                    attrs: {
+                        ...(description ? { id: (0, Utils_1.generateMessageID)() } : { delete: 'true' }),
+                        ...(prev ? { prev } : {})
+                    },
+                    content: description ? [{ tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }] : undefined
+                }
+            ]);
+        },
+        communityInviteCode: async (jid) => {
+            const result = await communityQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite');
+            return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code;
+        },
+        communityRevokeInvite: async (jid) => {
+            const result = await communityQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = (0, WABinary_1.getBinaryNodeChild)(result, 'invite');
+            return inviteNode === null || inviteNode === void 0 ? void 0 : inviteNode.attrs.code;
+        },
+        communityAcceptInvite: async (code) => {
+            const results = await communityQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
+            const result = (0, WABinary_1.getBinaryNodeChild)(results, 'community');
+            return result === null || result === void 0 ? void 0 : result.attrs.jid;
+        },
+        /**
+         * revoke a v4 invite for someone
+         * @param communityJid community jid
+         * @param invitedJid jid of person you invited
+         * @returns true if successful
+         */
+        communityRevokeInviteV4: async (communityJid, invitedJid) => {
+            const result = await communityQuery(communityJid, 'set', [
+                { tag: 'revoke', attrs: {}, content: [{ tag: 'participant', attrs: { jid: invitedJid } }] }
+            ]);
+            return !!result;
+        },
+        /**
+         * accept a CommunityInviteMessage
+         * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
+         * @param inviteMessage the message to accept
+         */
+        communityAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
+            var _a;
+            key = typeof key === 'string' ? { remoteJid: key } : key;
+            const results = await communityQuery(inviteMessage.groupJid, 'set', [
+                {
+                    tag: 'accept',
+                    attrs: {
+                        code: inviteMessage.inviteCode,
+                        expiration: inviteMessage.inviteExpiration.toString(),
+                        admin: key.remoteJid
+                    }
+                }
+            ]);
+            // if we have the full message key
+            // update the invite message to be expired
+            if (key.id) {
+                // create new invite message that is expired
+                inviteMessage = WAProto_1.proto.Message.GroupInviteMessage.fromObject(inviteMessage);
+                inviteMessage.inviteExpiration = 0;
+                inviteMessage.inviteCode = '';
+                ev.emit('messages.update', [
+                    {
+                        key,
+                        update: {
+                            message: {
+                                groupInviteMessage: inviteMessage
+                            }
+                        }
+                    }
+                ]);
+            }
+            // generate the community add message
+            await upsertMessage({
+                key: {
+                    remoteJid: inviteMessage.groupJid,
+                    id: (0, Utils_1.generateMessageIDV2)((_a = sock.user) === null || _a === void 0 ? void 0 : _a.id),
+                    fromMe: false,
+                    participant: key.remoteJid // TODO: investigate if this makes any sense at all
+                },
+                messageStubType: Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD,
+                messageStubParameters: [JSON.stringify(authState.creds.me)],
+                participant: key.remoteJid,
+                messageTimestamp: (0, Utils_1.unixTimestampSeconds)()
+            }, 'notify');
+            return results.attrs.from;
+        }),
+        communityGetInviteInfo: async (code) => {
+            const results = await communityQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
+            return (0, exports.extractCommunityMetadata)(results);
+        },
+        communityToggleEphemeral: async (jid, ephemeralExpiration) => {
+            const content = ephemeralExpiration
+                ? { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } }
+                : { tag: 'not_ephemeral', attrs: {} };
+            await communityQuery(jid, 'set', [content]);
+        },
+        communitySettingUpdate: async (jid, setting) => {
+            await communityQuery(jid, 'set', [{ tag: setting, attrs: {} }]);
+        },
+        communityMemberAddMode: async (jid, mode) => {
+            await communityQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }]);
+        },
+        communityJoinApprovalMode: async (jid, mode) => {
+            await communityQuery(jid, 'set', [
+                { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'community_join', attrs: { state: mode } }] }
+            ]);
+        },
+        communityFetchAllParticipating
+    };
+};
+exports.makeCommunitiesSocket = makeCommunitiesSocket;
+
+const extractCommunityMetadata = (result) => {
+    var _a, _b;
+    const community = (0, WABinary_1.getBinaryNodeChild)(result, 'community');
+    const descChild = (0, WABinary_1.getBinaryNodeChild)(community, 'description');
+    let desc;
+    let descId;
+    if (descChild) {
+        desc = (0, WABinary_1.getBinaryNodeChildString)(descChild, 'body');
+        descId = descChild.attrs.id;
+    }
+    const communityId = ((_a = community.attrs.id) === null || _a === void 0 ? void 0 : _a.includes('@'))
+        ? community.attrs.id
+        : (0, WABinary_1.jidEncode)(community.attrs.id || '', 'g.us');
+    const eph = (_b = (0, WABinary_1.getBinaryNodeChild)(community, 'ephemeral')) === null || _b === void 0 ? void 0 : _b.attrs.expiration;
+    const memberAddMode = (0, WABinary_1.getBinaryNodeChildString)(community, 'member_add_mode') === 'all_member_add';
+    const metadata = {
+        id: communityId,
+        subject: community.attrs.subject || '',
+        subjectOwner: community.attrs.s_o,
+        subjectTime: Number(community.attrs.s_t || 0),
+        size: (0, WABinary_1.getBinaryNodeChildren)(community, 'participant').length,
+        creation: Number(community.attrs.creation || 0),
+        owner: community.attrs.creator ? (0, WABinary_1.jidNormalizedUser)(community.attrs.creator) : undefined,
+        desc,
+        descId,
+        linkedParent: (0, WABinary_1.getBinaryNodeChild)(community, 'linked_parent')?.attrs.jid || undefined,
+        restrict: !!(0, WABinary_1.getBinaryNodeChild)(community, 'locked'),
+        announce: !!(0, WABinary_1.getBinaryNodeChild)(community, 'announcement'),
+        isCommunity: !!(0, WABinary_1.getBinaryNodeChild)(community, 'parent'),
+        isCommunityAnnounce: !!(0, WABinary_1.getBinaryNodeChild)(community, 'default_sub_community'),
+        joinApprovalMode: !!(0, WABinary_1.getBinaryNodeChild)(community, 'membership_approval_mode'),
+        memberAddMode,
+        participants: (0, WABinary_1.getBinaryNodeChildren)(community, 'participant').map(({ attrs }) => {
+            return {
+                id: attrs.jid,
+                admin: (attrs.type || null)
+            };
+        }),
+        ephemeralDuration: eph ? +eph : undefined,
+        addressingMode: (0, WABinary_1.getBinaryNodeChildString)(community, 'addressing_mode')
+    };
+    return metadata;
+};
+exports.extractCommunityMetadata = extractCommunityMetadata;

package/lib/Socket/index.js

@@ -1,10 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Defaults_1 = require("../Defaults");
-const business_1 = require("./business");
-// export the last socket layer
-const makeWASocket = (config) => ((0, business_1.makeBusinessSocket)({
-    ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
-    ...config
-}));
-exports.default = makeWASocket;
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { DEFAULT_CONNECTION_CONFIG } = require("../Defaults");
+const communities_1 = require("./communities"); 
+global.__SOCKET_MAP__ = global.__SOCKET_MAP__ || new Map()
+
+/**
+ * * @param {Object} config - Konfigurasi Baileys
+ * @param {String} sessionId - ID Unik
+ */
+const makeWASocket = (config, sessionId = 'primary') => {
+  if (global.__SOCKET_MAP__.has(sessionId)) {
+    const oldSock = global.__SOCKET_MAP__.get(sessionId)
+    
+    try {
+      oldSock.ws?.close?.()
+      oldSock.ws?.terminate?.()
+      oldSock.ws?.removeAllListeners?.()
+      oldSock.ev?.removeAllListeners?.()
+    } catch (e) {
+    }
+    global.__SOCKET_MAP__.delete(sessionId)
+  }
+  // -----------------------------------
+
+  const sock = (0, communities_1.makeCommunitiesSocket)({
+        ...Defaults_1.DEFAULT_CONNECTION_CONFIG,
+        ...config
+    });
+
+  global.__SOCKET_MAP__.set(sessionId, sock)
+  sock.ws.on('close', () => {
+      if (global.__SOCKET_MAP__.get(sessionId) === sock) {
+          global.__SOCKET_MAP__.delete(sessionId)
+      }
+  })
+
+  return sock
+}
+
+exports.default = makeWASocket

package/lib/Socket/messages-recv.js

@@ -747,10 +747,21 @@ const makeMessagesRecvSocket = (config) => {
         try {
             await Promise.all([
                 processingMutex.mutex(async () => {
-                    var _a, _b, _c, _d, _e, _f;
-                    await decrypt();
-                    // message failed to decrypt
+                    var _a, _b, _c, _d, _e, _f;                  
+                    try {
+                        await decrypt();
+                    } catch (err) {
+                        const errStr = String(err);
+               if (errStr.includes('Bad MAC') || errStr.includes('Invalid MAC')) {
+                 logger.warn({ msgId: node.attrs.id, from: node.attrs.from }, '⚠️ Bad MAC detected (Node 20/24 issue) - Forcing Retry...');                         
+                            msg.messageStubType = WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT;
+                            msg.messageStubParameters = [Utils_1.MISSING_KEYS_ERROR_TEXT];
+                        } else {
+                            throw err;
+                        }
+                    }
                     if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
+
                         if (((_a = msg === null || msg === void 0 ? void 0 : msg.messageStubParameters) === null || _a === void 0 ? void 0 : _a[0]) === Utils_1.MISSING_KEYS_ERROR_TEXT) {
                             return sendMessageAck(node, Utils_1.NACK_REASONS.ParsingError);
                         }

package/lib/Socket/socket.js

@@ -40,19 +40,6 @@ const makeSocket = (config) => {
         routingInfo: (_b = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _b === void 0 ? void 0 : _b.routingInfo
     });
     const { creds } = authState;
-    if (!creds.noiseKey?.public) {
-    creds.noiseKey = Utils_1.Curve.generateKeyPair()
-}
-
-if (!creds.signedIdentityKey?.public) {
-    creds.signedIdentityKey = Utils_1.Curve.generateKeyPair()
-}
-
-if (!creds.advSecretKey) {
-    creds.advSecretKey = (0, crypto_1.randomBytes)(32).toString('base64')
-}
-
-ev.emit('creds.update', creds)
     // add transaction capability
     const keys = (0, Utils_1.addTransactionCapability)(authState.keys, logger, transactionOpts);
     const signalRepository = makeSignalRepository({ creds, keys });
@@ -66,26 +53,20 @@ ev.emit('creds.update', creds)
     const sendPromise = (0, util_1.promisify)(ws.send);
     /** send a raw buffer */
     const sendRawMessage = async (data) => {
-    if (!ws || ws.isClosed || ws.isClosing || !ws.isOpen) {
-        throw new boom_1.Boom('Connection Closed', { 
-            statusCode: Types_1.DisconnectReason.connectionClosed 
-        })
-    }
-
-    const bytes = noise.encodeFrame(data)
-
-    await (0, Utils_1.promiseTimeout)(
-        connectTimeoutMs,
-        async (resolve, reject) => {
+        if (!ws.isOpen) {
+            throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
+        }
+        const bytes = noise.encodeFrame(data);
+        await (0, Utils_1.promiseTimeout)(connectTimeoutMs, async (resolve, reject) => {
             try {
-                await sendPromise.call(ws, bytes)
-                resolve()
-            } catch (error) {
-                reject(error)
+                await sendPromise.call(ws, bytes);
+                resolve();
             }
-        }
-    )
-};
+            catch (error) {
+                reject(error);
+            }
+        });
+    };
     /** send a binary node */
     const sendNode = (frame) => {
         if (logger.level === 'trace') {
@@ -413,104 +394,73 @@ const end = (error) => {
         end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
     };
     const requestPairingCode = async (phoneNumber, pairKey = "ELAINAMD") => {
-    if (!authState.creds.noiseKey?.public) {
-        authState.creds.noiseKey = Utils_1.Curve.generateKeyPair()
-        ev.emit('creds.update', authState.creds)
-    }
-
-    if (!authState.creds.pairingEphemeralKeyPair?.public) {
-        authState.creds.pairingEphemeralKeyPair = Utils_1.Curve.generateKeyPair()
-        ev.emit('creds.update', authState.creds)
-    }
-
-    if (pairKey) {
-        authState.creds.pairingCode = pairKey.toUpperCase()
-    } else {
-        authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5))
-    }
-
-    authState.creds.me = {
-        id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
-        name: '~'
-    }
-
-    ev.emit('creds.update', authState.creds)
-
-    await sendNode({
-        tag: 'iq',
-        attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
-            type: 'set',
-            id: generateMessageTag(),
-            xmlns: 'md'
-        },
-        content: [
-            {
-                tag: 'link_code_companion_reg',
-                attrs: {
-                    jid: authState.creds.me.id,
-                    stage: 'companion_hello',
-                    should_show_push_notification: 'true'
-                },
-                content: [
-                    {
-                        tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
-                        attrs: {},
-                        content: await generatePairingKey()
-                    },
-                    {
-                        tag: 'companion_server_auth_key_pub',
-                        attrs: {},
-                        content: authState.creds.noiseKey.public
-                    },
-                    {
-                        tag: 'companion_platform_id',
-                        attrs: {},
-                        content: (0, Utils_1.getPlatformId)(browser[1])
-                    },
-                    {
-                        tag: 'companion_platform_display',
-                        attrs: {},
-                        content: `${browser[1]} (${browser[0]})`
+        if (pairKey) {
+            authState.creds.pairingCode = pairKey.toUpperCase();
+        }
+        else {
+            authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
+        }
+        authState.creds.me = {
+            id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
+            name: '~'
+        };
+        ev.emit('creds.update', authState.creds);
+        await sendNode({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                id: generateMessageTag(),
+                xmlns: 'md'
+            },
+            content: [
+                {
+                    tag: 'link_code_companion_reg',
+                    attrs: {
+                        jid: authState.creds.me.id,
+                        stage: 'companion_hello',
+                        // eslint-disable-next-line camelcase
+                        should_show_push_notification: 'true'
                     },
-                    {
-                        tag: 'link_code_pairing_nonce',
-                        attrs: {},
-                        content: '0'
-                    }
-                ]
-            }
-        ]
-    })
-
-    return authState.creds.pairingCode
-    }
+                    content: [
+                        {
+                            tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
+                            attrs: {},
+                            content: await generatePairingKey()
+                        },
+                        {
+                            tag: 'companion_server_auth_key_pub',
+                            attrs: {},
+                            content: authState.creds.noiseKey.public
+                        },
+                        {
+                            tag: 'companion_platform_id',
+                            attrs: {},
+                            content: (0, Utils_1.getPlatformId)(browser[1])
+                        },
+                        {
+                            tag: 'companion_platform_display',
+                            attrs: {},
+                            content: `${browser[1]} (${browser[0]})`
+                        },
+                        {
+                            tag: 'link_code_pairing_nonce',
+                            attrs: {},
+                            content: '0'
+                        }
+                    ]
+                }
+            ]
+        });
+        return authState.creds.pairingCode;
+    };
     async function generatePairingKey() {
-    if (!authState.creds.pairingEphemeralKeyPair?.public) {
-        authState.creds.pairingEphemeralKeyPair = Utils_1.Curve.generateKeyPair()
-        ev.emit('creds.update', authState.creds)
+        const salt = (0, crypto_1.randomBytes)(32);
+        const randomIv = (0, crypto_1.randomBytes)(16);
+        const key = await (0, Utils_1.derivePairingCodeKey)(authState.creds.pairingCode, salt);
+        const ciphered = (0, Utils_1.aesEncryptCTR)(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
+        return Buffer.concat([salt, randomIv, ciphered]);
     }
-
-    if (!authState.creds.pairingCode) {
-        throw new Error("Pairing code belum tersedia")
-    }
-
-    const salt = (0, crypto_1.randomBytes)(32)
-    const randomIv = (0, crypto_1.randomBytes)(16)
-
-    const key = await (0, Utils_1.derivePairingCodeKey)(
-        authState.creds.pairingCode,
-        salt
-    )
-
-    const ciphered = (0, Utils_1.aesEncryptCTR)(
-        authState.creds.pairingEphemeralKeyPair.public,
-        key,
-        randomIv
-    )
-
-    return Buffer.concat([salt, randomIv, ciphered])
-}
     const sendWAMBuffer = (wamBuffer) => {
         return query({
             tag: 'iq',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexxhayanasi/elaina-baileys",
-  "version": "1.2.1-rc.5",
+  "version": "1.2.1-rc.6",
   "description": "Custom Baileys WhatsApp API",
   "keywords": [
     "baileys",