@badzz88/baileys 8.5.6 → 8.5.8

package/{src → lib}/Utils/use-multi-file-auth-state.js

@@ -1,28 +1,38 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.useMultiFileAuthState = void 0;
-const async_mutex_1 = require('async-mutex');
-const promises_1 = require('fs/promises');
-const path_1 = require('path');
-const index_js_1 = require('../../WAProto/index.js');
-const auth_utils_1 = require('./auth-utils');
-const generics_1 = require('./generics');
+import { Mutex } from 'async-mutex';
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
 const fileLocks = new Map();
-const getFileLock = path => {
+// Get or create a mutex for a specific file path
+const getFileLock = (path) => {
     let mutex = fileLocks.get(path);
     if (!mutex) {
-        mutex = new async_mutex_1.Mutex();
+        mutex = new Mutex();
         fileLocks.set(path, mutex);
     }
     return mutex;
 };
-const useMultiFileAuthState = async (folder) => {
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+export const useMultiFileAuthState = async (folder) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
-        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        const filePath = join(folder, fixFileName(file));
         const mutex = getFileLock(filePath);
         return mutex.acquire().then(async (release) => {
             try {
-                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer));
+                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
             }
             finally {
                 release();
@@ -31,12 +41,12 @@ const useMultiFileAuthState = async (folder) => {
     };
     const readData = async (file) => {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const filePath = join(folder, fixFileName(file));
             const mutex = getFileLock(filePath);
             return await mutex.acquire().then(async (release) => {
                 try {
-                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
-                    return JSON.parse(data, generics_1.BufferJSON.reviver);
+                    const data = await readFile(filePath, { encoding: 'utf-8' });
+                    return JSON.parse(data, BufferJSON.reviver);
                 }
                 finally {
                     release();
@@ -49,11 +59,11 @@ const useMultiFileAuthState = async (folder) => {
     };
     const removeData = async (file) => {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const filePath = join(folder, fixFileName(file));
             const mutex = getFileLock(filePath);
             return mutex.acquire().then(async (release) => {
                 try {
-                    await (0, promises_1.unlink)(filePath);
+                    await unlink(filePath);
                 }
                 catch {
                 }
@@ -64,17 +74,17 @@ const useMultiFileAuthState = async (folder) => {
         }
         catch { }
     };
-    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    const folderInfo = await stat(folder).catch(() => { });
     if (folderInfo) {
         if (!folderInfo.isDirectory()) {
             throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
         }
     }
     else {
-        await (0, promises_1.mkdir)(folder, { recursive: true });
+        await mkdir(folder, { recursive: true });
     }
-    const fixFileName = file => file?.replace(/\//g, '__')?.replace(/:/g, '-');
-    const creds = (await readData('creds.json')) || (0, auth_utils_1.initAuthCreds)();
+    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
+    const creds = (await readData('creds.json')) || initAuthCreds();
     return {
         state: {
             creds,
@@ -84,7 +94,7 @@ const useMultiFileAuthState = async (folder) => {
                     await Promise.all(ids.map(async (id) => {
                         let value = await readData(`${type}-${id}.json`);
                         if (type === 'app-state-sync-key' && value) {
-                            value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
                         }
                         data[id] = value;
                     }));
@@ -108,4 +118,4 @@ const useMultiFileAuthState = async (folder) => {
         }
     };
 };
-exports.useMultiFileAuthState = useMultiFileAuthState;
+//# sourceMappingURL=use-multi-file-auth-state.js.map

package/lib/Utils/validate-connection.js

@@ -0,0 +1,203 @@
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX } from '../Defaults/index.js';
+import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { Curve, hmacSign } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
+import { createSignalIdentity } from './signal.js';
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
+        },
+        platform: proto.ClientPayload.UserAgent.Platform.MACOS,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        localeLanguageIso6391: 'en',
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode
+    };
+};
+const PLATFORM_MAP = {
+    'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+};
+const getWebInfo = (config) => {
+    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory &&
+        PLATFORM_MAP[config.browser[0]] &&
+        config.browser[1] === 'Desktop') {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]];
+    }
+    return { webSubPlatform };
+};
+const getClientPayload = (config) => {
+    const payload = {
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    };
+    payload.webInfo = getWebInfo(config);
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
+    return payload;
+};
+export const generateLoginNode = (userJid, config) => {
+    const { user, device } = jidDecode(userJid);
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        // TODO: investigate (hard set as false atm)
+        lidDbMigrated: false
+    };
+    return proto.ClientPayload.fromObject(payload);
+};
+const getPlatformType = (platform) => {
+    const platformType = platform.toUpperCase();
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME);
+};
+export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
+    const appVersionBuf = createHash('md5')
+        .update(config.version.join('.')) // join as string
+        .digest();
+    const companion = {
+        os: config.browser[0],
+        platformType: getPlatformType(config.browser[1]),
+        requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: {
+            primary: 10,
+            secondary: 15,
+            tertiary: 7
+        }
+    };
+    const companionProto = proto.DeviceProps.encode(companion).finish();
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature
+        }
+    };
+    return proto.ClientPayload.fromObject(registerPayload);
+};
+export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+    const msgId = stanza.attrs.id;
+    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
+    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
+    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
+    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device');
+    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz');
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new Boom('Missing device-identity or device in pair success node', { data: stanza });
+    }
+    const bizName = businessNode?.attrs.name;
+    const jid = deviceNode.attrs.jid;
+    const lid = deviceNode.attrs.lid;
+    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+    }
+    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new Boom('Invalid account signature');
+    }
+    const account = proto.ADVSignedDeviceIdentity.decode(details);
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+    const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
+        ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : WA_ADV_ACCOUNT_SIG_PREFIX;
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new Boom('Failed to verify account signature');
+    }
+    const deviceMsg = Buffer.concat([
+        WA_ADV_DEVICE_SIG_PREFIX,
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = createSignalIdentity(lid, accountSignatureKey);
+    const accountEnc = encodeSignedDeviceIdentity(account, false);
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: S_WHATSAPP_NET,
+            type: 'result',
+            id: msgId
+        },
+        content: [
+            {
+                tag: 'pair-device-sign',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-identity',
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        content: accountEnc
+                    }
+                ]
+            }
+        ]
+    };
+    const authUpdate = {
+        account,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    };
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account };
+    // set to null if we are not to include the signature key
+    // or if we are including the signature key but it is empty
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};
+//# sourceMappingURL=validate-connection.js.map

package/{src → lib}/WABinary/constants.js

@@ -1,13 +1,9 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.TOKEN_MAP = exports.SINGLE_BYTE_TOKENS = exports.DOUBLE_BYTE_TOKENS = exports.TAGS = void 0;
-exports.TAGS = {
+export const TAGS = {
     LIST_EMPTY: 0,
     DICTIONARY_0: 236,
     DICTIONARY_1: 237,
     DICTIONARY_2: 238,
     DICTIONARY_3: 239,
-    INTEROP_JID_TUPLE: 244,
     INTEROP_JID: 245,
     FB_JID: 246,
     AD_JID: 247,
@@ -21,7 +17,7 @@ exports.TAGS = {
     NIBBLE_8: 255,
     PACKED_MAX: 127
 };
-exports.DOUBLE_BYTE_TOKENS = [
+export const DOUBLE_BYTE_TOKENS = [
     [
         'read-self',
         'active',
@@ -1055,7 +1051,7 @@ exports.DOUBLE_BYTE_TOKENS = [
         '1961'
     ]
 ];
-exports.SINGLE_BYTE_TOKENS = [
+export const SINGLE_BYTE_TOKENS = [
     '',
     'xmlstreamstart',
     'xmlstreamend',
@@ -1293,12 +1289,13 @@ exports.SINGLE_BYTE_TOKENS = [
     '03',
     'screen_height'
 ];
-exports.TOKEN_MAP = {};
-for (const [i, SINGLE_BYTE_TOKEN] of exports.SINGLE_BYTE_TOKENS.entries()) {
-    exports.TOKEN_MAP[SINGLE_BYTE_TOKEN] = { index: i };
+export const TOKEN_MAP = {};
+for (const [i, SINGLE_BYTE_TOKEN] of SINGLE_BYTE_TOKENS.entries()) {
+    TOKEN_MAP[SINGLE_BYTE_TOKEN] = { index: i };
 }
-for (const [i, DOUBLE_BYTE_TOKEN] of exports.DOUBLE_BYTE_TOKENS.entries()) {
+for (const [i, DOUBLE_BYTE_TOKEN] of DOUBLE_BYTE_TOKENS.entries()) {
     for (const [j, element] of DOUBLE_BYTE_TOKEN.entries()) {
-        exports.TOKEN_MAP[element] = { dict: i, index: j };
+        TOKEN_MAP[element] = { dict: i, index: j };
     }
 }
+//# sourceMappingURL=constants.js.map

package/{src → lib}/WABinary/decode.js

@@ -1,79 +1,21 @@
-'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 });
-exports.decodeBinaryNode = exports.decodeDecompressedBinaryNode = exports.decompressingIfRequired = void 0;
-const util_1 = require('util');
-const zlib_1 = require('zlib');
-const constants = __importStar(require('./constants'));
-const jid_utils_1 = require('./jid-utils');
-const inflatePromise = (0, util_1.promisify)(zlib_1.inflate);
-const decompressingIfRequired = async (buffer) => {
+import { promisify } from 'util';
+import { inflate } from 'zlib';
+import * as constants from './constants.js';
+import { jidEncode, WAJIDDomains } from './jid-utils.js';
+const inflatePromise = promisify(inflate);
+export const decompressingIfRequired = async (buffer) => {
     if (2 & buffer.readUInt8()) {
         buffer = await inflatePromise(buffer.slice(1));
     }
     else {
+        // nodes with no compression have a 0x00 prefix, we remove that
         buffer = buffer.slice(1);
     }
     return buffer;
 };
-exports.decompressingIfRequired = decompressingIfRequired;
-const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) => {
+export const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) => {
     const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts;
-    const checkEOS = length => {
+    const checkEOS = (length) => {
         if (indexRef.index + length > buffer.length) {
             throw new Error('end of stream');
         }
@@ -87,13 +29,13 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         checkEOS(1);
         return next();
     };
-    const readBytes = n => {
+    const readBytes = (n) => {
         checkEOS(n);
         const value = buffer.slice(indexRef.index, indexRef.index + n);
         indexRef.index += n;
         return value;
     };
-    const readStringFromChars = length => {
+    const readStringFromChars = (length) => {
         return readBytes(length).toString('utf-8');
     };
     const readInt = (n, littleEndian = false) => {
@@ -109,13 +51,13 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         checkEOS(3);
         return ((next() & 15) << 16) + (next() << 8) + next();
     };
-    const unpackHex = value => {
+    const unpackHex = (value) => {
         if (value >= 0 && value < 16) {
             return value < 10 ? '0'.charCodeAt(0) + value : 'A'.charCodeAt(0) + value - 10;
         }
         throw new Error('invalid hex: ' + value);
     };
-    const unpackNibble = value => {
+    const unpackNibble = (value) => {
         if (value >= 0 && value <= 9) {
             return '0'.charCodeAt(0) + value;
         }
@@ -141,7 +83,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
             throw new Error('unknown tag: ' + tag);
         }
     };
-    const readPacked8 = tag => {
+    const readPacked8 = (tag) => {
         const startByte = readByte();
         let value = '';
         for (let i = 0; i < (startByte & 127); i++) {
@@ -154,10 +96,10 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         }
         return value;
     };
-    const isListTag = tag => {
+    const isListTag = (tag) => {
         return tag === TAGS.LIST_EMPTY || tag === TAGS.LIST_8 || tag === TAGS.LIST_16;
     };
-    const readListSize = tag => {
+    const readListSize = (tag) => {
         switch (tag) {
             case TAGS.LIST_EMPTY:
                 return 0;
@@ -182,17 +124,17 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         const domainType = Number(rawDomainType);
         const device = readByte();
         const user = readString(readByte());
-        let server = 's.whatsapp.net';
-        if (domainType === jid_utils_1.WAJIDDomains.LID) {
+        let server = 's.whatsapp.net'; // default whatsapp server
+        if (domainType === WAJIDDomains.LID) {
             server = 'lid';
         }
-        else if (domainType === jid_utils_1.WAJIDDomains.HOSTED) {
+        else if (domainType === WAJIDDomains.HOSTED) {
             server = 'hosted';
         }
-        else if (domainType === jid_utils_1.WAJIDDomains.HOSTED_LID) {
+        else if (domainType === WAJIDDomains.HOSTED_LID) {
             server = 'hosted.lid';
         }
-        return (0, jid_utils_1.jidEncode)(user, server, device);
+        return jidEncode(user, server, device);
     };
     const readFbJid = () => {
         const user = readString(readByte());
@@ -205,33 +147,16 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         const device = readInt(2);
         const integrator = readInt(2);
         let server = 'interop';
-        if (indexRef.index < buffer.length) {
-            const serverTag = buffer[indexRef.index];
-            const isValidStringTag = (serverTag >= 1 && serverTag <= 235) ||
-                serverTag === TAGS.BINARY_8 ||
-                serverTag === TAGS.BINARY_20 ||
-                serverTag === TAGS.BINARY_32 ||
-                serverTag === TAGS.NIBBLE_8 ||
-                serverTag === TAGS.HEX_8;
-            if (isValidStringTag) {
-                indexRef.index++;
-                server = readString(serverTag);
-            }
+        const beforeServer = indexRef.index;
+        try {
+            server = readString(readByte());
         }
-        return `${integrator}-${user}:${device}@${server}`;
-    };
-    const readInteropJidTuple = () => {
-        const user = readString(readByte());
-        const device = readInt(2);
-        const integrator = readInt(2);
-        const domain = readByte();
-        if (domain !== 0) {
-            throw new Error(`invalid domain for INTEROP_JID_TUPLE: ${domain}`);
+        catch (err) {
+            indexRef.index = beforeServer;
         }
-        const devicePart = device !== 0 ? `:${device}` : '';
-        return `${integrator}-${user}${devicePart}@interop`;
+        return `${integrator}-${user}:${device}@${server}`;
     };
-    const readString = tag => {
+    const readString = (tag) => {
         if (tag >= 1 && tag < SINGLE_BYTE_TOKENS.length) {
             return SINGLE_BYTE_TOKENS[tag] || '';
         }
@@ -253,8 +178,6 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
                 return readJidPair();
             case TAGS.FB_JID:
                 return readFbJid();
-            case TAGS.INTEROP_JID_TUPLE:
-                return readInteropJidTuple();
             case TAGS.INTEROP_JID:
                 return readInteropJid();
             case TAGS.AD_JID:
@@ -263,28 +186,25 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
             case TAGS.NIBBLE_8:
                 return readPacked8(tag);
             default:
-                process.stderr.write(`[WABinary] unknown string tag 0x${tag.toString(16)} — token table outdated?\n`);
-                return '';
+                throw new Error('invalid string with tag: ' + tag);
         }
     };
-    const readList = tag => {
+    const readList = (tag) => {
         const items = [];
         const size = readListSize(tag);
         for (let i = 0; i < size; i++) {
-            items.push((0, exports.decodeDecompressedBinaryNode)(buffer, opts, indexRef));
+            items.push(decodeDecompressedBinaryNode(buffer, opts, indexRef));
         }
         return items;
     };
     const getTokenDouble = (index1, index2) => {
         const dict = DOUBLE_BYTE_TOKENS[index1];
         if (!dict) {
-            process.stderr.write(`[WABinary] unknown double-byte token dict ${index1} — token table outdated?\n`);
-            return '';
+            throw new Error(`Invalid double token dict (${index1})`);
         }
         const value = dict[index2];
         if (typeof value === 'undefined') {
-            process.stderr.write(`[WABinary] unknown double-byte token dict=${index1} idx=${index2} — token table outdated?\n`);
-            return '';
+            throw new Error(`Invalid double token (${index2})`);
         }
         return value;
     };
@@ -298,6 +218,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
     if (listSize === 0 || !header) {
         throw new Error('invalid node');
     }
+    // read the attributes in
     const attributesLength = (listSize - 1) >> 1;
     for (let i = 0; i < attributesLength; i++) {
         const key = readString(readByte());
@@ -334,9 +255,8 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         content: data
     };
 };
-exports.decodeDecompressedBinaryNode = decodeDecompressedBinaryNode;
-const decodeBinaryNode = buff => {
-    const buffer = Buffer.isBuffer(buff) ? buff : Buffer.from(buff);
-    return decodeDecompressedBinaryNode(buffer, constants);
+export const decodeBinaryNode = async (buff) => {
+    const decompBuff = await decompressingIfRequired(buff);
+    return decodeDecompressedBinaryNode(decompBuff, constants);
 };
-exports.decodeBinaryNode = decodeBinaryNode;
+//# sourceMappingURL=decode.js.map