@hansaka02/baileys 7.3.2 → 7.3.4

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

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const crypto_1 = require("@itsukichan/libsignal-node/src/crypto")
-const sender_message_key_1 = require("./sender-message-key")
+const { calculateMAC } = require("@itsukichan/libsignal-node/src/crypto")
+const { SenderMessageKey } = require("./sender-message-key")
 
 class SenderChainKey {
     constructor(iteration, chainKey) {
@@ -29,7 +29,7 @@ class SenderChainKey {
         return this.iteration
     }
     getSenderMessageKey() {
-        return new sender_message_key_1.SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey))
+        return new SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey))
     }
     getNext() {
         return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey))
@@ -38,7 +38,7 @@ class SenderChainKey {
         return this.chainKey
     }
     getDerivative(seed, key) {
-        return (0, crypto_1.calculateMAC)(key, seed)
+        return calculateMAC(key, seed)
     }
 }
 

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

@@ -2,16 +2,16 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const WAProto_1 = require("../../../WAProto")
-const ciphertext_message_1 = require("./ciphertext-message")
+const { proto } = require("../../../WAProto")
+const { CiphertextMessage } = require("./ciphertext-message")
 
-class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessage {
+class SenderKeyDistributionMessage extends CiphertextMessage {
     constructor(id, iteration, chainKey, signatureKey, serialized) {
         super()
         if (serialized) {
             try {
                 const message = serialized.slice(1)
-                const distributionMessage = WAProto_1.proto.SenderKeyDistributionMessage.decode(message).toJSON()
+                const distributionMessage = proto.SenderKeyDistributionMessage.decode(message).toJSON()
                 this.serialized = serialized
                 this.id = distributionMessage.id
                 this.iteration = distributionMessage.iteration
@@ -34,7 +34,7 @@ class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessag
             this.iteration = iteration
             this.chainKey = chainKey
             this.signatureKey = signatureKey
-            const message = WAProto_1.proto.SenderKeyDistributionMessage.encode(WAProto_1.proto.SenderKeyDistributionMessage.create({
+            const message = proto.SenderKeyDistributionMessage.encode(proto.SenderKeyDistributionMessage.create({
                 id,
                 iteration,
                 chainKey,

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

@@ -1,11 +1,15 @@
 "use strict"
+
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const curve_1 = require("@itsukichan/libsignal-node/src/curve")
-const WAProto_1 = require("../../../WAProto")
-const ciphertext_message_1 = require("./ciphertext-message")
+const {
+  verifySignature, 
+  calculateSignature
+} = require("@itsukichan/libsignal-node/src/curve")
+const { proto } = require("../../../WAProto")
+const { CiphertextMessage } = require("./ciphertext-message")
 
-class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
+class SenderKeyMessage extends CiphertextMessage {
     constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
         super()
         this.SIGNATURE_LENGTH = 64
@@ -13,7 +17,7 @@ class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
             const version = serialized[0]
             const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH)
             const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH)
-            const senderKeyMessage = WAProto_1.proto.SenderKeyMessage.decode(message).toJSON()
+            const senderKeyMessage = proto.SenderKeyMessage.decode(message).toJSON()
             this.serialized = serialized
             this.messageVersion = (version & 0xff) >> 4
             this.keyId = senderKeyMessage.id
@@ -27,7 +31,7 @@ class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
         else {
             const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256
             const ciphertextBuffer = Buffer.from(ciphertext)
-            const message = WAProto_1.proto.SenderKeyMessage.encode(WAProto_1.proto.SenderKeyMessage.create({
+            const message = proto.SenderKeyMessage.encode(proto.SenderKeyMessage.create({
                 id: keyId,
                 iteration: iteration,
                 ciphertext: ciphertextBuffer
@@ -53,12 +57,12 @@ class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
     verifySignature(signatureKey) {
         const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH)
         const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH)
-        const res = curve_1.verifySignature(signatureKey, part1, part2)
+        const res = verifySignature(signatureKey, part1, part2)
         if (!res)
             throw new Error('Invalid signature!')
     }
     getSignature(signatureKey, serialized) {
-        return Buffer.from(curve_1.calculateSignature(signatureKey, serialized))
+        return Buffer.from(calculateSignature(signatureKey, serialized))
     }
     serialize() {
         return this.serialized

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

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

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

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const sender_chain_key_1 = require("./sender-chain-key")
-const sender_message_key_1 = require("./sender-message-key")
+const { SenderChainKey } = require("./sender-chain-key")
+const { SenderMessageKey } = require("./sender-message-key")
 
 class SenderKeyState {
     constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
@@ -56,7 +56,7 @@ class SenderKeyState {
         return this.senderKeyStateStructure.senderKeyId
     }
     getSenderChainKey() {
-        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed)
+        return new SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed)
     }
     setSenderChainKey(chainKey) {
         this.senderKeyStateStructure.senderChainKey = {
@@ -133,7 +133,7 @@ class SenderKeyState {
         if (index !== -1) {
             const messageKey = this.senderKeyStateStructure.senderMessageKeys[index]
             this.senderKeyStateStructure.senderMessageKeys.splice(index, 1)
-            return new sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed)
+            return new SenderMessageKey(messageKey.iteration, messageKey.seed)
         }
         return null
     }

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

@@ -1,11 +1,11 @@
 "use strict"
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const crypto_1 = require("@itsukichan/libsignal-node/src/crypto")
+const { deriveSecrets } = require("@itsukichan/libsignal-node/src/crypto")
 
 class SenderMessageKey {
     constructor(iteration, seed) {
-        const derivative = (0, crypto_1.deriveSecrets)(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'))
+        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'))
         const keys = new Uint8Array(32)
         keys.set(new Uint8Array(derivative[0].slice(16)))
         keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16)

package/lib/Signal/libsignal.js

@@ -1,53 +1,29 @@
 "use strict"
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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) {
-            var ar = []
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
-            return ar
-        }
-        return ownKeys(o)
-    }
-    return function (mod) {
-        if (mod && mod.__esModule) return mod
-        var result = {}
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i])
-        __setModuleDefault(result, mod)
-        return result
-    }
-})()
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const libsignal = __importStar(require("@itsukichan/libsignal-node"))
-const Utils_1 = require("../Utils")
-const WABinary_1 = require("../WABinary")
-const sender_key_name_1 = require("./Group/sender-key-name")
-const sender_key_record_1 = require("./Group/sender-key-record")
-const Group_1 = require("./Group")
-const LIDMappingStore_1 = require("./lid-mapping") 
+const {
+  SessionCipher, 
+  SessionBuilder, 
+  SessionRecord, 
+  ProtocolAddress
+} = require("@itsukichan/libsignal-node")
+const { generateSignalPubKey } = require("../Utils")
+const {
+  jidDecode, 
+  transferDevice
+} = require("../WABinary")
+const { SenderKeyName } = require("./Group/sender-key-name")
+const { SenderKeyRecord } = require("./Group/sender-key-record")
+const {
+  GroupCipher, 
+  GroupSessionBuilder, 
+  SenderKeyDistributionMessage
+} = require("./Group")
+const { LIDMappingStore } = require("./lid-mapping") 
 
 function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
-	const lidMapping = new LIDMappingStore_1.LIDMappingStore(auth.keys, onWhatsAppFunc, logger)
+	const lidMapping = new LIDMappingStore(auth.keys, onWhatsAppFunc, logger)
     const storage = signalStorage(auth, lidMapping)
     const parsedKeys = auth.keys
     
@@ -63,35 +39,35 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
     const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid)
-            const cipher = new Group_1.GroupCipher(storage, senderName)
+            const cipher = new GroupCipher(storage, senderName)
             // Use transaction to ensure atomicity
             return parsedKeys.transaction(async () => {
                 return cipher.decrypt(msg)
             }, group)
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new Group_1.GroupSessionBuilder(storage)
+            const builder = new GroupSessionBuilder(storage)
             if (!item.groupId) {
                 throw new Error('Group ID is required for sender key distribution message')
             }
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
-            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
+            const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
             const senderNameStr = senderName.toString()
             const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+                await storage.storeSenderKey(senderName, new SenderKeyRecord())
             }
             return parsedKeys.transaction(async () => {
                 const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
                 if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+                    await storage.storeSenderKey(senderName, new SenderKeyRecord())
                 }
                 await builder.process(senderName, senderMsg)
             }, item.groupId)
         },
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid)
-            const session = new libsignal.SessionCipher(storage, addr)
+            const session = new SessionCipher(storage, addr)
             async function doDecrypt() {
                 let result
                 switch (type) {
@@ -141,7 +117,7 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
                 }
             }
             const addr = jidToSignalProtocolAddress(encryptionJid)
-            const cipher = new libsignal.SessionCipher(storage, addr)
+            const cipher = new SessionCipher(storage, addr)
             // Use transaction to ensure atomicity
             return parsedKeys.transaction(async () => {
                 const { type: sigType, body } = await cipher.encrypt(data)
@@ -151,15 +127,15 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId)
-            const builder = new Group_1.GroupSessionBuilder(storage)
+            const builder = new GroupSessionBuilder(storage)
             const senderNameStr = senderName.toString()
             return parsedKeys.transaction(async () => {
                 const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
                 if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+                    await storage.storeSenderKey(senderName, new SenderKeyRecord())
                 }
                 const senderKeyDistributionMessage = await builder.create(senderName)
-                const session = new Group_1.GroupCipher(storage, senderName)
+                const session = new GroupCipher(storage, senderName)
                 const ciphertext = await session.encrypt(data)
                 return {
                     ciphertext,
@@ -168,7 +144,7 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
             }, group)
         }, 
         async injectE2ESession({ jid, session }) {
-            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
+            const cipher = new SessionBuilder(storage, jidToSignalProtocolAddress(jid))
             return parsedKeys.transaction(async () => {
                 await cipher.initOutgoing(session)
             }, jid)
@@ -224,7 +200,7 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
             return parsedKeys.transaction(async () => {
                 // 1. Batch store all LID mappings
                 const mappings = validJids.map(jid => ({
-                    lid: WABinary_1.transferDevice(jid, toJid),
+                    lid: transferDevice(jid, toJid),
                     pn: jid
                 }))
                 
@@ -232,9 +208,9 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
                 
                 // 2. Prepare migration operations
                 const migrationOps = validJids.map(jid => {
-                    const lidWithDevice = WABinary_1.transferDevice(jid, toJid)
-                    const fromDecoded = WABinary_1.jidDecode(jid)
-                    const toDecoded = WABinary_1.jidDecode(lidWithDevice)
+                    const lidWithDevice = transferDevice(jid, toJid)
+                    const fromDecoded = jidDecode(jid)
+                    const toDecoded = jidDecode(lidWithDevice)
                     
                     return {
                         fromJid: jid,
@@ -266,7 +242,7 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
                     if (fromSession?.haveOpenSession()) {
                         // Copy session to LID address
                         const sessionBytes = fromSession.serialize()
-                        const copiedSession = libsignal.SessionRecord.deserialize(sessionBytes)
+                        const copiedSession = SessionRecord.deserialize(sessionBytes)
                         await storage.storeSession(op.toAddr.toString(), copiedSession)
                         
                         // Delete PN session
@@ -275,7 +251,7 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
                 }))
                 
                 return { migrated: opsToMigrate.length, skipped: skippedCount, total: validJids.length }
-            }, `migrate-${validJids.length}-sessions-${WABinary_1.jidDecode(toJid)?.user}`)
+            }, `migrate-${validJids.length}-sessions-${jidDecode(toJid)?.user}`)
         },
         async encryptMessageWithWire({ encryptionJid, wireJid, data }) {
             const result = await repository.encryptMessage({ jid: encryptionJid, data })
@@ -286,7 +262,7 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
 }
 
 const jidToSignalProtocolAddress = (jid) => {
-    const decoded = WABinary_1.jidDecode(jid)
+    const decoded = jidDecode(jid)
     const { user, device, server } = decoded
     
     if (!user) {
@@ -297,11 +273,11 @@ const jidToSignalProtocolAddress = (jid) => {
     const signalUser = server === 'lid' ? `${user}_1` : user
     const finalDevice = device || 0
     
-    return new libsignal.ProtocolAddress(signalUser, finalDevice)
+    return new ProtocolAddress(signalUser, finalDevice)
 }
 
 const jidToSignalSenderKeyName = (group, user) => {
-    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
+    return new SenderKeyName(group, jidToSignalProtocolAddress(user))
 }
 
 function signalStorage({ creds, keys }, lidMapping) {
@@ -329,7 +305,7 @@ function signalStorage({ creds, keys }, lidMapping) {
                 }
                 const { [actualId]: sess } = await keys.get('session', [actualId])
                 if (sess) {
-                    return libsignal.SessionRecord.deserialize(sess)
+                    return SessionRecord.deserialize(sess)
                 }
             }
             catch (e) {
@@ -337,7 +313,7 @@ function signalStorage({ creds, keys }, lidMapping) {
             }
             return null
         },
-        // TODO: Replace with libsignal.SessionRecord when type exports are added to libsignal
+        // TODO: Replace with SessionRecord when type exports are added to libsignal
         storeSession: async (id, session) => {
             await keys.set({ session: { [id]: session.serialize() } })
         },
@@ -366,9 +342,9 @@ function signalStorage({ creds, keys }, lidMapping) {
             const keyId = senderKeyName.toString()
             const { [keyId]: key } = await keys.get('sender-key', [keyId])
             if (key) {
-                return sender_key_record_1.SenderKeyRecord.deserialize(key)
+                return SenderKeyRecord.deserialize(key)
             }
-            return new sender_key_record_1.SenderKeyRecord()
+            return new SenderKeyRecord()
         },
         storeSenderKey: async (senderKeyName, key) => {
             const keyId = senderKeyName.toString()
@@ -380,7 +356,7 @@ function signalStorage({ creds, keys }, lidMapping) {
             const { signedIdentityKey } = creds
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Buffer.from(Utils_1.generateSignalPubKey(signedIdentityKey.public)) 
+                pubKey: Buffer.from(generateSignalPubKey(signedIdentityKey.public)) 
             }
         }
     }

package/lib/Signal/lid-mapping.js

@@ -2,12 +2,16 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const lru_cache_1 = require("lru-cache")
-const WABinary_1 = require("../WABinary")
+const { LRUCache } = require("lru-cache")
+const {
+  jidDecode, 
+  isJidUser, 
+  isLidUser
+} = require("../WABinary")
 
 class LIDMappingStore {
 	constructor(keys, onWhatsAppFunc, logger) {
-		this.mappingCache = new lru_cache_1.LRUCache({
+		this.mappingCache = new LRUCache({
             ttl: 7 * 24 * 60 * 60 * 1000, // 7 days
             ttlAutopurge: true,
             updateAgeOnGet: true
@@ -25,13 +29,13 @@ class LIDMappingStore {
         const logger = this.logger
         
         for (const { lid, pn } of pairs) {
-            if (!((WABinary_1.isLidUser(lid) && WABinary_1.isJidUser(pn)) || (WABinary_1.isJidUser(lid) && WABinary_1.isLidUser(pn)))) {
+            if (!((isLidUser(lid) && isJidUser(pn)) || (isJidUser(lid) && isLidUser(pn)))) {
                 logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
                 continue
             }
             
-            const lidDecoded = WABinary_1.jidDecode(lid)
-            const pnDecoded = WABinary_1.jidDecode(pn)
+            const lidDecoded = jidDecode(lid)
+            const pnDecoded = jidDecode(pn)
             
             if (!lidDecoded || !pnDecoded) return
             
@@ -83,10 +87,10 @@ class LIDMappingStore {
      * Get LID for PN - Returns device-specific LID based on user mapping
      */
     async getLIDForPN(pn) {
-        if (!WABinary_1.isJidUser(pn)) return null
+        if (!isJidUser(pn)) return null
         
         const logger = this.logger
-        const decoded = WABinary_1.jidDecode(pn)
+        const decoded = jidDecode(pn)
         
         if (!decoded) return null
         
@@ -113,7 +117,7 @@ class LIDMappingStore {
                 const { exists, lid } = (await this.onWhatsAppFunc?.(pn))?.[0] // this function already adds LIDs to mapping
                 
                 if (exists && lid) {
-                    lidUser = WABinary_1.jidDecode(lid)?.user
+                    lidUser = jidDecode(lid)?.user
                     
                     if (lidUser) {
                         // Cache the USync result
@@ -144,10 +148,10 @@ class LIDMappingStore {
      * Get PN for LID - USER LEVEL with device construction
      */
      async getPNForLID(lid) {
-        if (!WABinary_1.isLidUser(lid)) return null
+        if (!isLidUser(lid)) return null
         
         const logger = this.logger
-        const decoded = WABinary_1.jidDecode(lid)
+        const decoded = jidDecode(lid)
         
         if (!decoded) return null
         

package/lib/Socket/Client/types.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const events_1 = require("events")
+const { EventEmitter } = require("events")
 
-class AbstractSocketClient extends events_1.EventEmitter {
+class AbstractSocketClient extends EventEmitter {
     constructor(url, config) {
         super()
         this.url = url

package/lib/Socket/Client/websocket.js

@@ -1,38 +1,40 @@
 "use strict"
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const ws_1 = __importDefault(require("ws"))
-const Defaults_1 = require("../../Defaults")
-const types_1 = require("./types")
+const {
+  OPEN, 
+  CLOSED, 
+  CLOSING, 
+  CONNECTING, 
+  WebSocket
+} = require("ws")
+const { DEFAULT_ORIGIN } = require("../../Defaults/constants")
+const { AbstractSocketClient } = require("./types")
 
-class WebSocketClient extends types_1.AbstractSocketClient {
+class WebSocketClient extends AbstractSocketClient {
     constructor() {
         super(...arguments)
         this.socket = null
     }
     get isOpen() {
-        return this.socket?.readyState === ws_1.default.OPEN
+        return this.socket?.readyState === OPEN
     }
     get isClosed() {
-        return this.socket?.readyState === ws_1.default.CLOSED
+        return this.socket?.readyState === CLOSED
     }
     get isClosing() {
-        this.socket?.readyState === ws_1.default.CLOSING
+        this.socket?.readyState === CLOSING
     }
     get isConnecting() {
-        this.socket?.readyState === ws_1.default.CONNECTING
+        this.socket?.readyState === CONNECTING
     }
     async connect() {
         if (this.socket) {
             return
         }
-        this.socket = new ws_1.default(this.url, {
-            origin: Defaults_1.DEFAULT_ORIGIN,
+        this.socket = new WebSocket(this.url, {
+            origin: DEFAULT_ORIGIN,
             headers: this.config.options?.headers,
             handshakeTimeout: this.config.connectTimeoutMs,
             timeout: this.config.connectTimeoutMs,