@blckrose/baileys 1.0.0 → 1.1.1

package/lib/Defaults/index.js

@@ -1,4 +1,8 @@
 import { proto } from '../../WAProto/index.js';
+import { readFileSync } from 'node:fs';
+const phoneNumberMcc = JSON.parse(
+  readFileSync(new URL('./phonenumber-mcc.json', import.meta.url))
+);
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
@@ -125,4 +129,5 @@ export const TimeMs = {
     Day: 24 * 60 * 60 * 1000,
     Week: 7 * 24 * 60 * 60 * 1000
 };
+export const PHONENUMBER_MCC = phoneNumberMcc;
 //# sourceMappingURL=index.js.map

package/lib/Defaults/phonenumber-mcc.json

@@ -0,0 +1,223 @@
+{
+	"93": 412,
+	"355": 276,
+	"213": 603,
+	"1-684": 544,
+	"376": 213,
+	"244": 631,
+	"1-264": 365,
+	"1-268": 344,
+	"54": 722,
+	"374": 283,
+	"297": 363,
+	"61": 505,
+	"43": 232,
+	"994": 400,
+	"1-242": 364,
+	"973": 426,
+	"880": 470,
+	"1-246": 342,
+	"375": 257,
+	"32": 206,
+	"501": 702,
+	"229": 616,
+	"1-441": 350,
+	"975": 402,
+	"591": 736,
+	"387": 218,
+	"267": 652,
+	"55": 724,
+	"1-284": 348,
+	"673": 528,
+	"359": 284,
+	"226": 613,
+	"257": 642,
+	"855": 456,
+	"237": 624,
+	"238": 625,
+	"1-345": 346,
+	"236": 623,
+	"235": 622,
+	"56": 730,
+	"86": 454,
+	"57": 732,
+	"269": 654,
+	"682": 548,
+	"506": 712,
+	"385": 219,
+	"53": 368,
+	"357": 280,
+	"420": 230,
+	"243": 630,
+	"45": 238,
+	"253": 638,
+	"1-767": 366,
+	"1-809": 370,
+	"1-849": 370,
+	"1-829": 370,
+	"593": 740,
+	"20": 602,
+	"503": 706,
+	"240": 627,
+	"291": 657,
+	"372": 248,
+	"251": 636,
+	"500": 750,
+	"298": 288,
+	"679": 542,
+	"358": 244,
+	"33": 208,
+	"689": 547,
+	"241": 628,
+	"220": 607,
+	"995": 282,
+	"49": 262,
+	"233": 620,
+	"350": 266,
+	"30": 202,
+	"299": 290,
+	"1-473": 352,
+	"1-671": 535,
+	"502": 704,
+	"224": 537,
+	"592": 738,
+	"509": 372,
+	"504": 708,
+	"852": 454,
+	"36": 216,
+	"354": 274,
+	"91": 404,
+	"62": 510,
+	"98": 432,
+	"964": 418,
+	"353": 234,
+	"972": 425,
+	"39": 222,
+	"225": 612,
+	"1-876": 338,
+	"81": 440,
+	"962": 416,
+	"254": 639,
+	"686": 545,
+	"383": 221,
+	"965": 419,
+	"371": 247,
+	"961": 415,
+	"266": 651,
+	"231": 618,
+	"218": 606,
+	"423": 295,
+	"370": 246,
+	"352": 270,
+	"389": 294,
+	"261": 646,
+	"265": 650,
+	"60": 502,
+	"960": 472,
+	"223": 610,
+	"356": 278,
+	"692": 551,
+	"222": 609,
+	"230": 617,
+	"52": 334,
+	"691": 550,
+	"373": 259,
+	"377": 212,
+	"976": 428,
+	"382": 297,
+	"1-664": 354,
+	"212": 604,
+	"258": 643,
+	"95": 414,
+	"264": 649,
+	"674": 536,
+	"977": 429,
+	"31": 204,
+	"687": 546,
+	"64": 530,
+	"505": 710,
+	"227": 614,
+	"234": 621,
+	"683": 555,
+	"1-670": 534,
+	"47": 242,
+	"968": 226,
+	"92": 410,
+	"680": 552,
+	"970": 423,
+	"507": 714,
+	"675": 537,
+	"595": 744,
+	"51": 716,
+	"63": 515,
+	"48": 260,
+	"351": 268,
+	"1-787, 1-939": 330,
+	"974": 427,
+	"242": 630,
+	"40": 226,
+	"7": 250,
+	"250": 635,
+	"290": 658,
+	"1-869": 356,
+	"1-758": 358,
+	"508": 308,
+	"1-784": 360,
+	"685": 544,
+	"378": 292,
+	"239": 626,
+	"966": 420,
+	"221": 608,
+	"381": 220,
+	"248": 633,
+	"232": 619,
+	"65": 525,
+	"386": 293,
+	"677": 540,
+	"27": 655,
+	"211": 659,
+	"34": 214,
+	"94": 413,
+	"249": 634,
+	"597": 746,
+	"268": 653,
+	"46": 240,
+	"41": 228,
+	"963": 417,
+	"886": 466,
+	"992": 436,
+	"255": 640,
+	"66": 520,
+	"228": 615,
+	"690": 554,
+	"676": 539,
+	"1-868": 374,
+	"216": 605,
+	"90": 286,
+	"993": 438,
+	"1-649": 376,
+	"688": 553,
+	"1-340": 332,
+	"256": 641,
+	"380": 255,
+	"971": 424,
+	"44": 234,
+	"1": 310,
+	"598": 748,
+	"998": 434,
+	"678": 541,
+	"379": 225,
+	"58": 734,
+	"681": 543,
+	"967": 421,
+	"260": 645,
+	"263": 648,
+	"670": 514,
+	"245": 632,
+	"856": 457,
+	"599": 362,
+	"850": 467,
+	"262": 647,
+	"82": 450,
+	"84": 452
+}

package/lib/Signal/libsignal.js

@@ -3,6 +3,15 @@ import * as libsignal from 'libsignal';
 // @ts-ignore
 import { PreKeyWhisperMessage } from 'libsignal/src/protobufs.js';
 import { LRUCache } from 'lru-cache';
+// ── Suppress libsignal "Closing session: SessionEntry {...}" console spam ─────
+const _$origLog = console.log;
+console.log = (...args) => {
+    const first = typeof args[0] === 'string' ? args[0] : (args[0] instanceof Object ? args[0]?.constructor?.name : '');
+    if (first === 'Closing session:' || (typeof args[0] === 'object' && args[0]?.constructor?.name === 'SessionEntry')) return;
+    if (typeof args[0] === 'string' && (args[0].startsWith('Closing session') || args[0].includes('SessionEntry'))) return;
+    _$origLog.apply(console, args);
+};
+// ─────────────────────────────────────────────────────────────────────────────
 import { generateSignalPubKey } from '../Utils/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from '../WABinary/index.js';
 import { SenderKeyName } from './Group/sender-key-name.js';
@@ -85,13 +94,16 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             }
             async function doDecrypt() {
                 let result;
-                switch (type) {
-                    case 'pkmsg':
-                        result = await session.decryptPreKeyWhisperMessage(ciphertext);
-                        break;
-                    case 'msg':
-                        result = await session.decryptWhisperMessage(ciphertext);
-                        break;
+                try {
+                    switch (type) {
+                        case 'pkmsg':
+                            result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                            break;
+                        case 'msg':
+                            result = await session.decryptWhisperMessage(ciphertext);
+                            break;
+                    }
+                } finally {
                 }
                 return result;
             }

package/lib/Socket/community.js

@@ -0,0 +1,361 @@
+import { proto } from '../../WAProto/index.js';
+import { WAMessageStubType } from '../Types/index.js';
+import { generateMessageID, unixTimestampSeconds } from '../Utils/index.js';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { makeBusinessSocket } from './business.js';
+
+export const makeCommunitiesSocket = (config) => {
+    const sock = makeBusinessSocket(config);
+    const { authState, ev, query, groupMetadata, 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 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 = getBinaryNodeChild(result, 'communities');
+
+        if (communitiesChild) {
+            const communities = getBinaryNodeChildren(communitiesChild, 'community');
+            for (const communityNode of communities) {
+                const meta = extractCommunityMetadata({
+                    tag: 'result',
+                    attrs: {},
+                    content: [communityNode]
+                });
+                data[meta.id] = meta;
+            }
+        }
+
+        sock.ev.emit('groups.update', Object.values(data));
+        return data;
+    };
+
+    sock.ws.on('CB:ib,,dirty', async (node) => {
+        const { attrs } = getBinaryNodeChild(node, 'dirty');
+
+        if (attrs.type !== 'communities') {
+            return;
+        }
+
+        await communityFetchAllParticipating();
+        await sock.cleanDirtyBits('groups');
+    });
+
+    return {
+        ...sock,
+        communityQuery,
+        communityMetadata,
+        communityCreate: async (subject, body) => {
+            const descriptionId = 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 extractCommunityMetadata(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')
+                }
+            ]);
+        },
+        communityRequestParticipantsList: async (jid) => {
+            const result = await communityQuery(jid, 'get', [
+                {
+                    tag: 'membership_approval_requests',
+                    attrs: {}
+                }
+            ]);
+
+            const node = getBinaryNodeChild(result, 'membership_approval_requests');
+            const participants = 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 = getBinaryNodeChild(result, 'membership_requests_action');
+            const nodeAction = getBinaryNodeChild(node, action);
+            const participantsAffected = 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: {},
+                    content: participants.map(jid => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ]);
+            const node = getBinaryNodeChild(result, action);
+            const participantsAffected = 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 ? metadata.descId : null;
+
+            await communityQuery(jid, 'set', [
+                {
+                    tag: 'description',
+                    attrs: {
+                        ...(description ? { id: 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 = getBinaryNodeChild(result, 'invite');
+
+            return inviteNode?.attrs?.code;
+        },
+        communityRevokeInvite: async (jid) => {
+            const result = await communityQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = getBinaryNodeChild(result, 'invite');
+
+            return inviteNode?.attrs?.code;
+        },
+        communityAcceptInvite: async (code) => {
+            const results = await communityQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
+            const result = getBinaryNodeChild(results, 'community');
+
+            return 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 GroupInviteMessage
+         * @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) => {
+            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 = proto.Message.GroupInviteMessage.fromObject(inviteMessage);
+                inviteMessage.inviteExpiration = 0;
+                inviteMessage.inviteCode = '';
+                ev.emit('messages.update', [
+                    {
+                        key,
+                        update: {
+                            message: {
+                                groupInviteMessage: inviteMessage
+                            }
+                        }
+                    }
+                ]);
+            }
+
+            // generate the group add message
+            await upsertMessage({
+                key: {
+                    remoteJid: inviteMessage.groupJid,
+                    id: generateMessageID(authState.creds.me?.id),
+                    fromMe: false,
+                    participant: key.remoteJid,
+                },
+                messageStubType: WAMessageStubType.GROUP_PARTICIPANT_ADD,
+                messageStubParameters: [
+                    authState.creds.me.id
+                ],
+                participant: key.remoteJid,
+                messageTimestamp: unixTimestampSeconds()
+            }, 'notify');
+
+            return results.attrs.from;
+        }),
+        communityGetInviteInfo: async (code) => {
+            const results = await communityQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
+
+            return 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
+    };
+};
+
+export const extractCommunityMetadata = (result) => {
+    const community = getBinaryNodeChild(result, 'group');
+    const descChild = getBinaryNodeChild(community, 'description');
+
+    let desc;
+    let descId;
+
+    if (descChild) {
+        desc = getBinaryNodeChildString(descChild, 'body');
+        descId = descChild.attrs.id;
+    }
+
+    const mode = community.attrs.addressing_mode;
+    const communityId = community.attrs.id.includes('@') ? community.attrs.id : jidEncode(community.attrs.id, 'g.us');
+    const eph = getBinaryNodeChild(community, 'ephemeral')?.attrs.expiration;
+    const memberAddMode = getBinaryNodeChildString(community, 'member_add_mode') === 'all_member_add';
+
+    const metadata = {
+        id: communityId,
+        addressingMode: mode,
+        subject: community.attrs.subject,
+        subjectOwner: mode === 'lid' ? community.attrs.s_o_pn : community.attrs.s_o,
+        subjectTime: +community.attrs.s_t,
+        size: community.attrs?.size ? +community.attrs.size : getBinaryNodeChildren(community, 'participant').length,
+        creation: +community.attrs.creation,
+        owner: community.attrs.creator ? jidNormalizedUser(mode === 'lid' ? community.attrs.creator_pn : community.attrs.creator) : undefined,
+        desc,
+        descId,
+        linkedParent: getBinaryNodeChild(community, 'linked_parent')?.attrs.jid || undefined,
+        restrict: !!getBinaryNodeChild(community, 'locked'),
+        announce: !!getBinaryNodeChild(community, 'announcement'),
+        isCommunity: !!getBinaryNodeChild(community, 'parent'),
+        isCommunityAnnounce: !!getBinaryNodeChild(community, 'default_sub_group'),
+        joinApprovalMode: !!getBinaryNodeChild(community, 'membership_approval_mode'),
+        memberAddMode,
+        participants: getBinaryNodeChildren(community, 'participant').map(({ attrs }) => {
+            return {
+                id: mode === 'lid' ? community.phone_number : attrs.jid,
+                lid: mode === 'lid' ? community.jid : attrs.lid,
+                admin: (attrs.type || null),
+            };
+        }),
+        ephemeralDuration: eph ? +eph : undefined,
+    };
+
+    return metadata;
+};