@heavstaltech/baileys 2.3.4 → 3.2.4

package/lib/Utils/auth-utils.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initAuthCreds = exports.addTransactionCapability = void 0;
-exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
+exports.initAuthCreds = exports.addTransactionCapability = exports.makeCacheableSignalKeyStore = void 0;
 const crypto_1 = require("crypto");
 const node_cache_1 = __importDefault(require("node-cache"));
 const uuid_1 = require("uuid");
@@ -19,30 +18,9 @@ const generics_1 = require("./generics");
  */
 function makeCacheableSignalKeyStore(store, logger, _cache) {
     const cache = _cache || new node_cache_1.default({
-      stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
-      useClones: false,
-      deleteOnExpire: true,
-      checkperiod: 120
-    });
-  
-    cache.on('expired', async (key) => {
-      const [type, id] = key.split('.');
-      const item = cache.get(key, { noUpdate: true });
-      if (item) {
-        try {
-          await store.set({
-            [type]: {
-              [id]: item
-            }
-          });
-          cache.del(key);
-        } catch (error) {
-          logger?.error({
-            key
-          }, 'Failed to persist expired cache item');
-          cache.ttl(key, 60);
-        }
-      }
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        useClones: false,
+        deleteOnExpire: true,
     });
     function getUniqueId(type, id) {
         return `${type}.${id}`;
@@ -52,7 +30,7 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
             const data = {};
             const idsToFetch = [];
             for (const id of ids) {
-                const item = cache.get(getUniqueId(type, id), { noUpdate: true });
+                const item = cache.get(getUniqueId(type, id));
                 if (typeof item !== 'undefined') {
                     data[id] = item;
                 }
@@ -61,7 +39,7 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
                 }
             }
             if (idsToFetch.length) {
-                logger?.trace({ items: idsToFetch.length }, 'loading from store');
+                logger.trace({ items: idsToFetch.length }, 'loading from store');
                 const fetched = await store.get(type, idsToFetch);
                 for (const id of idsToFetch) {
                     const item = fetched[id];
@@ -81,7 +59,7 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
                     keys += 1;
                 }
             }
-            logger?.trace({ keys }, 'updated cache');
+            logger.trace({ keys }, 'updated cache');
             await store.set(data);
         },
         async clear() {
@@ -91,6 +69,7 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
         }
     };
 }
+exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
 /**
  * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
  * this allows batch read & write operations & improves the performance of the lib
@@ -134,7 +113,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
         },
         set: data => {
             if (isInTransaction()) {
-                logger?.trace({ types: Object.keys(data) }, 'caching in transaction');
+                logger.trace({ types: Object.keys(data) }, 'caching in transaction');
                 for (const key in data) {
                     transactionCache[key] = transactionCache[key] || {};
                     Object.assign(transactionCache[key], data[key]);
@@ -151,14 +130,14 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             let result;
             transactionsInProgress += 1;
             if (transactionsInProgress === 1) {
-                logger?.trace('entering transaction');
+                logger.trace('entering transaction');
             }
             try {
                 result = await work();
                 // commit if this is the outermost transaction
                 if (transactionsInProgress === 1) {
                     if (Object.keys(mutations).length) {
-                        logger?.trace('committing transaction');
+                        logger.trace('committing transaction');
                         // retry mechanism to ensure we've some recovery
                         // in case a transaction fails in the first attempt
                         let tries = maxCommitRetries;
@@ -166,17 +145,17 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                             tries -= 1;
                             try {
                                 await state.set(mutations);
-                                logger?.trace({ dbQueriesInTransaction }, 'committed transaction');
+                                logger.trace({ dbQueriesInTransaction }, 'committed transaction');
                                 break;
                             }
                             catch (error) {
-                                logger?.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
+                                logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
                                 await (0, generics_1.delay)(delayBetweenTriesMs);
                             }
                         }
                     }
                     else {
-                        logger?.trace('no mutations in transaction');
+                        logger.trace('no mutations in transaction');
                     }
                 }
             }

package/lib/Utils/business.d.ts

@@ -2,7 +2,7 @@ import { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate,
 import { BinaryNode } from '../WABinary';
 export declare const parseCatalogNode: (node: BinaryNode) => {
     products: Product[];
-    nextPageCursor: any;
+    nextPageCursor: string | undefined;
 };
 export declare const parseCollectionsNode: (node: BinaryNode) => {
     collections: CatalogCollection[];

package/lib/Utils/business.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadingNecessaryImages = exports.parseProductNode = exports.toProductNode = exports.parseOrderDetailsNode = exports.parseCollectionsNode = exports.parseCatalogNode = void 0;
-exports.uploadingNecessaryImagesOfProduct = uploadingNecessaryImagesOfProduct;
+exports.uploadingNecessaryImages = exports.uploadingNecessaryImagesOfProduct = exports.parseProductNode = exports.toProductNode = exports.parseOrderDetailsNode = exports.parseCollectionsNode = exports.parseCatalogNode = void 0;
 const boom_1 = require("@hapi/boom");
 const crypto_1 = require("crypto");
 const WABinary_1 = require("../WABinary");
@@ -189,6 +188,7 @@ async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, time
     };
     return product;
 }
+exports.uploadingNecessaryImagesOfProduct = uploadingNecessaryImagesOfProduct;
 /**
  * Uploads images not already uploaded to WA's servers
  */

package/lib/Utils/chat-utils.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { AxiosRequestConfig } from 'axios';
 import type { Logger } from 'pino';
 import { proto } from '../../WAProto';
@@ -13,7 +14,7 @@ export declare const encodeSyncdPatch: ({ type, index, syncAction, apiVersion, o
     state: LTHashState;
 }>;
 export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation | proto.ISyncdRecord)[], initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
-    hash: any;
+    hash: Buffer;
     indexValueMap: {
         [indexMacBase64: string]: {
             valueMac: Uint8Array | Buffer;
@@ -21,47 +22,47 @@ export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation
     };
 }>;
 export declare const decodeSyncdPatch: (msg: proto.ISyncdPatch, name: WAPatchName, initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
-    hash: any;
+    hash: Buffer;
     indexValueMap: {
         [indexMacBase64: string]: {
             valueMac: Uint8Array | Buffer;
         };
     };
 }>;
-export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<{}>) => Promise<{
+export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<any>) => Promise<{
     critical_block: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
-        snapshot?: proto.ISyncdSnapshot;
+        snapshot?: proto.ISyncdSnapshot | undefined;
     };
     critical_unblock_low: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
-        snapshot?: proto.ISyncdSnapshot;
+        snapshot?: proto.ISyncdSnapshot | undefined;
     };
     regular_high: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
-        snapshot?: proto.ISyncdSnapshot;
+        snapshot?: proto.ISyncdSnapshot | undefined;
     };
     regular_low: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
-        snapshot?: proto.ISyncdSnapshot;
+        snapshot?: proto.ISyncdSnapshot | undefined;
     };
     regular: {
         patches: proto.ISyncdPatch[];
         hasMorePatches: boolean;
-        snapshot?: proto.ISyncdSnapshot;
+        snapshot?: proto.ISyncdSnapshot | undefined;
     };
 }>;
-export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<any>;
-export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<proto.SyncdMutations>;
+export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<Buffer>;
+export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<proto.SyncdMutations>;
 export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
     state: LTHashState;
     mutationMap: ChatMutationMap;
 }>;
-export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<{}>, minimumVersionNumber?: number, logger?: Logger, validateMacs?: boolean) => Promise<{
+export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<any>, minimumVersionNumber?: number, logger?: Logger, validateMacs?: boolean) => Promise<{
     state: LTHashState;
     mutationMap: ChatMutationMap;
 }>;

package/lib/Utils/chat-utils.js

@@ -9,8 +9,8 @@ const crypto_1 = require("./crypto");
 const generics_1 = require("./generics");
 const lt_hash_1 = require("./lt-hash");
 const messages_media_1 = require("./messages-media");
-const mutationKeys = async (keydata) => {
-    const expanded = await (0, crypto_1.hkdf)(keydata, 160, { info: 'WhatsApp Mutation Keys' });
+const mutationKeys = (keydata) => {
+    const expanded = (0, crypto_1.hkdf)(keydata, 160, { info: 'WhatsApp Mutation Keys' });
     return {
         indexKey: expanded.slice(0, 32),
         valueEncryptionKey: expanded.slice(32, 64),
@@ -69,9 +69,9 @@ const makeLtHashGenerator = ({ indexValueMap, hash }) => {
                 subBuffs.push(new Uint8Array(prevOp.valueMac).buffer);
             }
         },
-        finish: async () => {
+        finish: () => {
             const hashArrayBuffer = new Uint8Array(hash).buffer;
-            const result = await lt_hash_1.LT_HASH_ANTI_TAMPERING.subtractThenAdd(hashArrayBuffer, addBuffs, subBuffs);
+            const result = lt_hash_1.LT_HASH_ANTI_TAMPERING.subtractThenAdd(hashArrayBuffer, addBuffs, subBuffs);
             const buffer = Buffer.from(result);
             return {
                 hash: buffer,
@@ -114,14 +114,14 @@ const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, operation
         version: apiVersion
     });
     const encoded = WAProto_1.proto.SyncActionData.encode(dataProto).finish();
-    const keyValue = await mutationKeys(key.keyData);
+    const keyValue = mutationKeys(key.keyData);
     const encValue = (0, crypto_1.aesEncrypt)(encoded, keyValue.valueEncryptionKey);
     const valueMac = generateMac(operation, encValue, encKeyId, keyValue.valueMacKey);
     const indexMac = (0, crypto_1.hmacSign)(indexBuffer, keyValue.indexKey);
     // update LT hash
     const generator = makeLtHashGenerator(state);
     generator.mix({ indexMac, valueMac, operation });
-    Object.assign(state, await generator.finish());
+    Object.assign(state, generator.finish());
     state.version += 1;
     const snapshotMac = generateSnapshotMac(state.hash, state.version, type, keyValue.snapshotMacKey);
     const patch = {
@@ -184,7 +184,7 @@ const decodeSyncdMutations = async (msgMutations, initialState, getAppStateSyncK
             operation: operation
         });
     }
-    return await ltGenerator.finish();
+    return ltGenerator.finish();
     async function getKey(keyId) {
         const base64Key = Buffer.from(keyId).toString('base64');
         const keyEnc = await getAppStateSyncKey(base64Key);
@@ -202,7 +202,7 @@ const decodeSyncdPatch = async (msg, name, initialState, getAppStateSyncKey, onM
         if (!mainKeyObj) {
             throw new boom_1.Boom(`failed to find key "${base64Key}" to decode patch`, { statusCode: 404, data: { msg } });
         }
-        const mainKey = await mutationKeys(mainKeyObj.keyData);
+        const mainKey = mutationKeys(mainKeyObj.keyData);
         const mutationmacs = msg.mutations.map(mutation => mutation.record.value.blob.slice(-32));
         const patchMac = generatePatchMac(msg.snapshotMac, mutationmacs, (0, generics_1.toNumber)(msg.version.version), name, mainKey.patchMacKey);
         if (Buffer.compare(patchMac, msg.patchMac) !== 0) {
@@ -286,7 +286,7 @@ const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, minimumVe
         if (!keyEnc) {
             throw new boom_1.Boom(`failed to find key "${base64Key}" to decode mutation`);
         }
-        const result = await mutationKeys(keyEnc.keyData);
+        const result = mutationKeys(keyEnc.keyData);
         const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
         if (Buffer.compare(snapshot.mac, computedSnapshotMac) !== 0) {
             throw new boom_1.Boom(`failed to verify LTHash at ${newState.version} of ${name} from snapshot`);
@@ -305,7 +305,8 @@ const decodePatches = async (name, syncds, initial, getAppStateSyncKey, options,
         indexValueMap: { ...initial.indexValueMap }
     };
     const mutationMap = {};
-    for (const syncd of syncds) {
+    for (let i = 0; i < syncds.length; i++) {
+        const syncd = syncds[i];
         const { version, keyId, snapshotMac } = syncd;
         if (syncd.externalMutations) {
             logger === null || logger === void 0 ? void 0 : logger.trace({ name, version }, 'downloading external patch');
@@ -331,7 +332,7 @@ const decodePatches = async (name, syncds, initial, getAppStateSyncKey, options,
             if (!keyEnc) {
                 throw new boom_1.Boom(`failed to find key "${base64Key}" to decode mutation`);
             }
-            const result = await mutationKeys(keyEnc.keyData);
+            const result = mutationKeys(keyEnc.keyData);
             const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
             if (Buffer.compare(snapshotMac, computedSnapshotMac) !== 0) {
                 throw new boom_1.Boom(`failed to verify LTHash at ${newState.version} of ${name}`);
@@ -417,31 +418,25 @@ const chatModificationToAppPatch = (mod, jid) => {
             operation: OP.SET
         };
     }
-    else if ('deleteForMe' in mod) {
-        const { timestamp, key, deleteMedia } = mod.deleteForMe;
-        patch = {
-            syncAction: {
-                deleteMessageForMeAction: {
-                    deleteMedia,
-                    messageTimestamp: timestamp
-                }
-            },
-            index: ['deleteMessageForMe', jid, key.id, key.fromMe ? '1' : '0', '0'],
-            type: 'regular_high',
-            apiVersion: 3,
-            operation: OP.SET
-        };
-    }
     else if ('clear' in mod) {
-        patch = {
-            syncAction: {
-                clearChatAction: {} // add message range later
-            },
-            index: ['clearChat', jid, '1' /*the option here is 0 when keep starred messages is enabled*/, '0'],
-            type: 'regular_high',
-            apiVersion: 6,
-            operation: OP.SET
-        };
+        if (mod.clear === 'all') {
+            throw new boom_1.Boom('not supported');
+        }
+        else {
+            const key = mod.clear.messages[0];
+            patch = {
+                syncAction: {
+                    deleteMessageForMeAction: {
+                        deleteMedia: false,
+                        messageTimestamp: key.timestamp
+                    }
+                },
+                index: ['deleteMessageForMe', jid, key.id, key.fromMe ? '1' : '0', '0'],
+                type: 'regular_high',
+                apiVersion: 3,
+                operation: OP.SET
+            };
+        }
     }
     else if ('pin' in mod) {
         patch = {
@@ -496,22 +491,6 @@ const chatModificationToAppPatch = (mod, jid) => {
             operation: OP.SET,
         };
     }
-    else if ('addLabel' in mod) {
-        patch = {
-            syncAction: {
-                labelEditAction: {
-                    name: mod.addLabel.name,
-                    color: mod.addLabel.color,
-                    predefinedId: mod.addLabel.predefinedId,
-                    deleted: mod.addLabel.deleted
-                }
-            },
-            index: ['label_edit', mod.addLabel.id],
-            type: 'regular',
-            apiVersion: 3,
-            operation: OP.SET,
-        };
-    }
     else if ('addChatLabel' in mod) {
         patch = {
             syncAction: {
@@ -654,7 +633,12 @@ const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) => {
         });
     }
     else if (action === null || action === void 0 ? void 0 : action.contactAction) {
-        ev.emit('contacts.upsert', [{ id, name: action.contactAction.fullName }]);
+        ev.emit('contacts.upsert', [{ 
+            id: id,
+            name: action.contactAction.fullName,
+            lid: action.contactAction.lidJid || undefined,
+            jid: (0, WABinary_1.isJidUser)(id) ? id : undefined
+        }]);
     }
     else if (action === null || action === void 0 ? void 0 : action.pushNameSetting) {
         const name = (_b = action === null || action === void 0 ? void 0 : action.pushNameSetting) === null || _b === void 0 ? void 0 : _b.name;

package/lib/Utils/crypto.d.ts

@@ -1,9 +1,10 @@
+/// <reference types="node" />
 import { KeyPair } from '../Types';
 /** prefix version byte to the pub keys, required for some curve crypto functions */
-export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => any;
+export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => Uint8Array | Buffer;
 export declare const Curve: {
     generateKeyPair: () => KeyPair;
-    sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => any;
+    sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => Buffer;
     sign: (privateKey: Uint8Array, buf: Uint8Array) => any;
     verify: (pubKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => boolean;
 };
@@ -16,25 +17,25 @@ export declare const signedKeyPair: (identityKeyPair: KeyPair, keyId: number) =>
  * encrypt AES 256 GCM;
  * where the tag tag is suffixed to the ciphertext
  * */
-export declare function aesEncryptGCM(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): any;
+export declare function aesEncryptGCM(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer;
 /**
  * decrypt AES 256 GCM;
  * where the auth tag is suffixed to the ciphertext
  * */
-export declare function aesDecryptGCM(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): any;
-export declare function aesEncryptCTR(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): any;
-export declare function aesDecryptCTR(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): any;
+export declare function aesDecryptGCM(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer;
+export declare function aesEncryptCTR(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer;
+export declare function aesDecryptCTR(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer;
 /** decrypt AES 256 CBC; where the IV is prefixed to the buffer */
-export declare function aesDecrypt(buffer: Buffer, key: Buffer): any;
+export declare function aesDecrypt(buffer: Buffer, key: Buffer): Buffer;
 /** decrypt AES 256 CBC */
-export declare function aesDecryptWithIV(buffer: Buffer, key: Buffer, IV: Buffer): any;
-export declare function aesEncrypt(buffer: Buffer | Uint8Array, key: Buffer): any;
-export declare function aesEncrypWithIV(buffer: Buffer, key: Buffer, IV: Buffer): any;
-export declare function hmacSign(buffer: Buffer | Uint8Array, key: Buffer | Uint8Array, variant?: 'sha256' | 'sha512'): any;
-export declare function sha256(buffer: Buffer): any;
-export declare function md5(buffer: Buffer): any;
+export declare function aesDecryptWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer;
+export declare function aesEncrypt(buffer: Buffer | Uint8Array, key: Buffer): Buffer;
+export declare function aesEncrypWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer;
+export declare function hmacSign(buffer: Buffer | Uint8Array, key: Buffer | Uint8Array, variant?: 'sha256' | 'sha512'): Buffer;
+export declare function sha256(buffer: Buffer): Buffer;
+export declare function md5(buffer: Buffer): Buffer;
 export declare function hkdf(buffer: Uint8Array | Buffer, expandedLength: number, info: {
     salt?: Buffer;
     info?: string;
-}): any;
-export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Promise<any>;
+}): Buffer;
+export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Buffer;

package/lib/Utils/crypto.js

@@ -15,48 +15,22 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signedKeyPair = exports.Curve = exports.generateSignalPubKey = void 0;
-exports.aesEncryptGCM = aesEncryptGCM;
-exports.aesDecryptGCM = aesDecryptGCM;
-exports.aesEncryptCTR = aesEncryptCTR;
-exports.aesDecryptCTR = aesDecryptCTR;
-exports.aesDecrypt = aesDecrypt;
-exports.aesDecryptWithIV = aesDecryptWithIV;
-exports.aesEncrypt = aesEncrypt;
-exports.aesEncrypWithIV = aesEncrypWithIV;
-exports.hmacSign = hmacSign;
-exports.sha256 = sha256;
-exports.md5 = md5;
-exports.hkdf = hkdf;
-exports.derivePairingCodeKey = derivePairingCodeKey;
+exports.derivePairingCodeKey = exports.hkdf = exports.md5 = exports.sha256 = exports.hmacSign = exports.aesEncrypWithIV = exports.aesEncrypt = exports.aesDecryptWithIV = exports.aesDecrypt = exports.aesDecryptCTR = exports.aesEncryptCTR = exports.aesDecryptGCM = exports.aesEncryptGCM = exports.signedKeyPair = exports.Curve = exports.generateSignalPubKey = void 0;
 const crypto_1 = require("crypto");
-const crypto_2 = globalThis.crypto ?? crypto_1.webcrypto ?? crypto_1;
-//const futoin_hkdf_1 = __importDefault(require("futoin-hkdf"));
+const futoin_hkdf_1 = __importDefault(require("futoin-hkdf"));
 const libsignal = __importStar(require("libsignal"));
-const util_1 = require("util");
 const Defaults_1 = require("../Defaults");
-//const pbkdf2Promise = (0, util_1.promisify)(crypto_1.pbkdf2);
 /** prefix version byte to the pub keys, required for some curve crypto functions */
 const generateSignalPubKey = (pubKey) => (pubKey.length === 33
     ? pubKey
@@ -103,6 +77,7 @@ function aesEncryptGCM(plaintext, key, iv, additionalData) {
     cipher.setAAD(additionalData);
     return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);
 }
+exports.aesEncryptGCM = aesEncryptGCM;
 /**
  * decrypt AES 256 GCM;
  * where the auth tag is suffixed to the ciphertext
@@ -117,83 +92,60 @@ function aesDecryptGCM(ciphertext, key, iv, additionalData) {
     decipher.setAuthTag(tag);
     return Buffer.concat([decipher.update(enc), decipher.final()]);
 }
+exports.aesDecryptGCM = aesDecryptGCM;
 function aesEncryptCTR(plaintext, key, iv) {
     const cipher = (0, crypto_1.createCipheriv)('aes-256-ctr', key, iv);
     return Buffer.concat([cipher.update(plaintext), cipher.final()]);
 }
+exports.aesEncryptCTR = aesEncryptCTR;
 function aesDecryptCTR(ciphertext, key, iv) {
     const decipher = (0, crypto_1.createDecipheriv)('aes-256-ctr', key, iv);
     return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
 }
+exports.aesDecryptCTR = aesDecryptCTR;
 /** decrypt AES 256 CBC; where the IV is prefixed to the buffer */
 function aesDecrypt(buffer, key) {
     return aesDecryptWithIV(buffer.slice(16, buffer.length), key, buffer.slice(0, 16));
 }
+exports.aesDecrypt = aesDecrypt;
 /** decrypt AES 256 CBC */
 function aesDecryptWithIV(buffer, key, IV) {
     const aes = (0, crypto_1.createDecipheriv)('aes-256-cbc', key, IV);
     return Buffer.concat([aes.update(buffer), aes.final()]);
 }
+exports.aesDecryptWithIV = aesDecryptWithIV;
 // encrypt AES 256 CBC; where a random IV is prefixed to the buffer
 function aesEncrypt(buffer, key) {
     const IV = (0, crypto_1.randomBytes)(16);
     const aes = (0, crypto_1.createCipheriv)('aes-256-cbc', key, IV);
     return Buffer.concat([IV, aes.update(buffer), aes.final()]); // prefix IV to the buffer
 }
+exports.aesEncrypt = aesEncrypt;
 // encrypt AES 256 CBC with a given IV
 function aesEncrypWithIV(buffer, key, IV) {
     const aes = (0, crypto_1.createCipheriv)('aes-256-cbc', key, IV);
     return Buffer.concat([aes.update(buffer), aes.final()]); // prefix IV to the buffer
 }
+exports.aesEncrypWithIV = aesEncrypWithIV;
 // sign HMAC using SHA 256
 function hmacSign(buffer, key, variant = 'sha256') {
     return (0, crypto_1.createHmac)(variant, key).update(buffer).digest();
 }
+exports.hmacSign = hmacSign;
 function sha256(buffer) {
     return (0, crypto_1.createHash)('sha256').update(buffer).digest();
 }
+exports.sha256 = sha256;
 function md5(buffer) {
     return (0, crypto_1.createHash)('md5').update(buffer).digest();
 }
+exports.md5 = md5;
 // HKDF key expansion
-async function hkdf(buffer, expandedLength, info) {
-    // Ensure we have a Uint8Array for the key material
-    const inputKeyMaterial = buffer instanceof Uint8Array
-        ? buffer
-        : new Uint8Array(buffer);
-    // Set default values if not provided
-    const salt = info.salt ? new Uint8Array(info.salt) : new Uint8Array(0);
-    const infoBytes = info.info
-        ? new TextEncoder().encode(info.info)
-        : new Uint8Array(0);
-    // Import the input key material
-    const importedKey = await crypto_2.subtle.importKey('raw', inputKeyMaterial, { name: 'HKDF' }, false, ['deriveBits']);
-    // Derive bits using HKDF
-    const derivedBits = await crypto_2.subtle.deriveBits({
-        name: 'HKDF',
-        hash: 'SHA-256',
-        salt: salt,
-        info: infoBytes
-    }, importedKey, expandedLength * 8 // Convert bytes to bits
-    );
-    return Buffer.from(derivedBits);
+function hkdf(buffer, expandedLength, info) {
+    return (0, futoin_hkdf_1.default)(!Buffer.isBuffer(buffer) ? Buffer.from(buffer) : buffer, expandedLength, info);
 }
-async function derivePairingCodeKey(pairingCode, salt) {
-    // Convert inputs to formats Web Crypto API can work with
-    const encoder = new TextEncoder();
-    const pairingCodeBuffer = encoder.encode(pairingCode);
-    const saltBuffer = salt instanceof Uint8Array ? salt : new Uint8Array(salt);
-    // Import the pairing code as key material
-    const keyMaterial = await crypto_2.subtle.importKey('raw', pairingCodeBuffer, { name: 'PBKDF2' }, false, ['deriveBits']);
-    // Derive bits using PBKDF2 with the same parameters
-    // 2 << 16 = 131,072 iterations
-    const derivedBits = await crypto_2.subtle.deriveBits({
-        name: 'PBKDF2',
-        salt: saltBuffer,
-        iterations: 2 << 16,
-        hash: 'SHA-256'
-    }, keyMaterial, 32 * 8 // 32 bytes * 8 = 256 bits
-    );
-    return Buffer.from(derivedBits);
+exports.hkdf = hkdf;
+function derivePairingCodeKey(pairingCode, salt) {
+    return (0, crypto_1.pbkdf2Sync)(pairingCode, salt, 2 << 16, 32, 'sha256');
 }
-
+exports.derivePairingCodeKey = derivePairingCodeKey;

package/lib/Utils/decode-wa-message.d.ts

@@ -2,23 +2,6 @@ import { Logger } from 'pino';
 import { proto } from '../../WAProto';
 import { SignalRepository } from '../Types';
 import { BinaryNode } from '../WABinary';
-export declare const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node";
-export declare const MISSING_KEYS_ERROR_TEXT = "Key used already or never filled";
-export declare const NACK_REASONS: {
-    ParsingError: number;
-    UnrecognizedStanza: number;
-    UnrecognizedStanzaClass: number;
-    UnrecognizedStanzaType: number;
-    InvalidProtobuf: number;
-    InvalidHostedCompanionStanza: number;
-    MissingMessageSecret: number;
-    SignalErrorOldCounter: number;
-    MessageDeletedOnPeer: number;
-    UnhandledError: number;
-    UnsupportedAdminRevoke: number;
-    UnsupportedLIDGroup: number;
-    DBOperationFailed: number;
-};
 /**
  * Decode the received node as a message.
  * @note this will only parse the message, not decrypt it