kage-baileys 3.0.6 → 3.2.4

package/lib/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,142 @@
+"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.useSqliteAuthState = useSqliteAuthState;
+const index_js_1 = require("../../WAProto/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./generics.js");
+async function loadBetterSqlite3() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = (await Promise.resolve().then(() => __importStar(require('better-sqlite3'))));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for `useSqliteAuthState`. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+const CREDS_ROW_KEY = '__creds__';
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS creds (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS signal_keys (
+  type TEXT NOT NULL,
+  id TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (type, id)
+);
+CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
+`;
+async function useSqliteAuthState(opts) {
+    let db;
+    if (opts.database) {
+        db = opts.database;
+    }
+    else {
+        const Database = await loadBetterSqlite3();
+        db = new Database(opts.dbPath);
+    }
+    // WAL mode allows concurrent reads alongside a single writer; matches
+    // what SQLite recommends for read-heavy workloads with sporadic writes.
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.exec(CREATE_SCHEMA_SQL);
+    const stmts = {
+        credsSelect: db.prepare('SELECT value FROM creds WHERE key = ?'),
+        credsUpsert: db.prepare('INSERT INTO creds (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
+        keySelect: db.prepare('SELECT value FROM signal_keys WHERE type = ? AND id = ?'),
+        keyUpsert: db.prepare('INSERT INTO signal_keys (type, id, value) VALUES (?, ?, ?) ON CONFLICT(type, id) DO UPDATE SET value = excluded.value'),
+        keyDelete: db.prepare('DELETE FROM signal_keys WHERE type = ? AND id = ?'),
+        keyListIds: db.prepare('SELECT id FROM signal_keys WHERE type = ?'),
+        keyList: db.prepare('SELECT id, value FROM signal_keys WHERE type = ?'),
+        clearKeys: db.prepare('DELETE FROM signal_keys')
+    };
+    const loadCreds = () => {
+        const row = stmts.credsSelect.get(CREDS_ROW_KEY);
+        if (!row)
+            return (0, auth_utils_js_1.initAuthCreds)();
+        return JSON.parse(row.value, generics_js_1.BufferJSON.reviver);
+    };
+    const persistCreds = (creds) => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, generics_js_1.BufferJSON.replacer));
+    };
+    const creds = loadCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const row = stmts.keySelect.get(type, id);
+                        if (row) {
+                            let value = JSON.parse(row.value, generics_js_1.BufferJSON.reviver);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            data[id] = value;
+                        }
+                    }
+                    return data;
+                },
+                set: async (data) => {
+                    const writeTx = db.transaction(() => {
+                        for (const category in data) {
+                            for (const id in data[category]) {
+                                const value = data[category][id];
+                                if (value) {
+                                    const stringified = JSON.stringify(value, generics_js_1.BufferJSON.replacer);
+                                    stmts.keyUpsert.run(category, id, stringified);
+                                }
+                                else {
+                                    stmts.keyDelete.run(category, id);
+                                }
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => {
+            persistCreds(creds);
+        }
+    };
+}

package/lib/Utils/validate-connection.js

@@ -226,4 +226,500 @@ const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
         .encode(account)
         .finish();
 };
-exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;
+// Kage: compatibilidad de API.
+const __kageModule80 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { Boom } = require("@hapi/boom")
+const { createHash } = require("crypto")
+const { proto } = require("../../WAProto")
+const {
+  KEY_BUNDLE_TYPE, 
+  WA_ADV_ACCOUNT_SIG_PREFIX, 
+  WA_ADV_DEVICE_SIG_PREFIX, 
+  WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+} = require("../Defaults/constants")
+const {
+  jidDecode, 
+  getBinaryNodeChild,
+  S_WHATSAPP_NET
+} = require("../WABinary")
+const {
+  Curve, 
+  hmacSign 
+} = require("./crypto")
+const { encodeBigEndian } = require("./generics")
+const { createSignalIdentity } = require("./signal")
+
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2],
+        },
+        platform: /*config.browser[1].toLocaleLowerCase().includes('android') 
+                         ? proto.ClientPayload.UserAgent.Platform.ANDROID 
+                         :*/ proto.ClientPayload.UserAgent.Platform.WEB,
+        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),
+    }
+    
+    /*if (!config.browser[1].toLocaleLowerCase().includes('android')) { 
+   	 payload.webInfo = getWebInfo(config) 
+    }*/
+    payload.webInfo = getWebInfo(config) 
+    
+    return payload
+}
+
+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()
+    
+     /*if (platformType === 'ANDROID') { 
+     	return proto.DeviceProps.PlatformType.ANDROID_PHONE
+     }*/
+     
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME)
+}
+
+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)
+}
+
+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
+    }
+}
+
+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()
+}
+
+module.exports = {
+  generateLoginNode, 
+  generateRegistrationNode, 
+  configureSuccessfulPairing, 
+  encodeSignedDeviceIdentity
+}
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule80)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule80[key]});
+}
+
+// Kage: funciones avanzadas.
+const __kageModule189 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../Addon/index.js");
+const index_js_3 = require("../Defaults/index.js");
+const index_js_4 = require("../WABinary/index.js");
+const crypto_js_1 = require("./crypto.js");
+const generics_js_1 = require("./generics.js");
+const signal_js_1 = require("./signal.js");
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
+        },
+        platform: config.browser[1].toLocaleLowerCase().includes('android')
+            ? index_js_1.proto.ClientPayload.UserAgent.Platform.ANDROID
+            : index_js_1.proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: index_js_1.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': index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
+};
+const getWebInfo = (config) => {
+    let webSubPlatform = index_js_1.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: index_js_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: index_js_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    };
+    if (!config.browser[1].toLocaleLowerCase().includes('android')) {
+        payload.webInfo = getWebInfo(config);
+    }
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
+    return payload;
+};
+const generateLoginNode = (userJid, config) => {
+    const { user, device } = (0, index_js_4.jidDecode)(userJid);
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        // TODO: investigate (hard set as false atm)
+        lidDbMigrated: false
+    };
+    return index_js_1.proto.ClientPayload.fromObject(payload);
+};
+exports.generateLoginNode = generateLoginNode;
+const getPlatformType = (platform) => {
+    const platformType = platform.toUpperCase();
+    if (platformType === 'ANDROID') {
+        return index_js_1.proto.DeviceProps.PlatformType.ANDROID_PHONE;
+    }
+    return (index_js_1.proto.DeviceProps.PlatformType[platformType] ||
+        index_js_1.proto.DeviceProps.PlatformType.CHROME);
+};
+const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
+    const appVersionBuf = (0, node_crypto_1.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 = index_js_1.proto.DeviceProps.encode(companion).finish();
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: (0, generics_js_1.encodeBigEndian)(registrationId),
+            eKeytype: index_js_3.KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: (0, generics_js_1.encodeBigEndian)(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature
+        }
+    };
+    return index_js_1.proto.ClientPayload.fromObject(registerPayload);
+};
+exports.generateRegistrationNode = generateRegistrationNode;
+const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+    const msgId = stanza.attrs.id;
+    const pairSuccessNode = (0, index_js_4.getBinaryNodeChild)(stanza, 'pair-success');
+    const deviceIdentityNode = (0, index_js_4.getBinaryNodeChild)(pairSuccessNode, 'device-identity');
+    const platformNode = (0, index_js_4.getBinaryNodeChild)(pairSuccessNode, 'platform');
+    const deviceNode = (0, index_js_4.getBinaryNodeChild)(pairSuccessNode, 'device');
+    const businessNode = (0, index_js_4.getBinaryNodeChild)(pairSuccessNode, 'biz');
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new index_js_2.HttpError('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 } = index_js_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === index_js_1.proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = index_js_3.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+    }
+    const advSign = (0, crypto_js_1.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new index_js_2.HttpError('Invalid account signature');
+    }
+    const account = index_js_1.proto.ADVSignedDeviceIdentity.decode(details);
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+    const deviceIdentity = index_js_1.proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === index_js_1.proto.ADVEncryptionType.HOSTED
+        ? index_js_3.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : index_js_3.WA_ADV_ACCOUNT_SIG_PREFIX;
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    if (!crypto_js_1.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new index_js_2.HttpError('Failed to verify account signature');
+    }
+    const deviceMsg = Buffer.concat([
+        index_js_3.WA_ADV_DEVICE_SIG_PREFIX,
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = crypto_js_1.Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = (0, signal_js_1.createSignalIdentity)(lid, accountSignatureKey);
+    const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: index_js_4.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,
+        registered: true
+    };
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+exports.configureSuccessfulPairing = configureSuccessfulPairing;
+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 index_js_1.proto.ADVSignedDeviceIdentity.encode(account).finish();
+};
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;
+
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule189)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule189[key]});
+}
+Object.defineProperty(exports, Symbol.for('kage.advanced'), {value:__kageModule189, configurable:true});

package/lib/Utils/view-once-compat.js

@@ -7,7 +7,7 @@ function getViewOnceContent(raw) {
   let message = raw?.message ?? raw;
   let viewOnce = false;
   for (let i = 0; i < 12 && message && typeof message === 'object'; i++) {
-    const wrapper = ['ephemeralMessage', 'documentWithCaptionMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'].find(k => message[k]?.message);
+    const wrapper = ['deviceSentMessage', 'ephemeralMessage', 'documentWithCaptionMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'].find(k => message[k]?.message);
     if (wrapper) { viewOnce ||= wrapper.startsWith('viewOnce'); message = message[wrapper].message; continue; }
     const type = types.find(k => message[k]);
     if (!type) return null;
@@ -40,12 +40,19 @@ async function resendViewOnceMessage(conn, raw, options = {}) {
   if (field === 'document') body.fileName = value.fileName || 'archivo';
   return conn.sendMessage(options.jid || raw.key.remoteJid, body, options.quoted ? { quoted: options.quoted } : {});
 }
-function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
+async function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
   const chat = raw?.key?.remoteJid;
-  const active = () => Array.isArray(settings.autoViewOnceChats) && settings.autoViewOnceChats.includes(chat);
+  const normalize = jid => String(jid || '').replace(/:\d+@/, '@');
+  const aliases = new Set([chat, raw?.key?.remoteJidAlt].filter(Boolean).map(normalize));
+  for (const jid of [...aliases]) {
+    if (jid.endsWith('@lid')) {
+      try { const pn = await conn.signalRepository?.lidMapping?.getPNForLID?.(jid); if (pn) aliases.add(normalize(pn)); } catch {}
+    }
+  }
+  const active = () => Array.isArray(settings.autoViewOnceChats) && settings.autoViewOnceChats.some(jid => aliases.has(normalize(jid)));
   // Preserve the explicitly consented archive API for existing library clients.
   if (!active()) return require('./consented-media').handleConsentedAutoViewOnce(raw, conn, settings, options);
-  if (!raw?.key?.id || raw.key.fromMe || !/@(s\.whatsapp\.net|lid|g\.us)$/.test(chat || '') || !getViewOnceContent(raw)?.viewOnce) return Promise.resolve(null);
+  if (!raw?.key?.id || (raw.key.fromMe && !settings.autoViewOnceOwn) || !/@(s\.whatsapp\.net|lid|g\.us)$/.test(chat || '') || !getViewOnceContent(raw)?.viewOnce) return Promise.resolve(null);
   const timestamp = Number(raw.messageTimestamp?.toNumber?.() ?? raw.messageTimestamp ?? 0) * 1000;
   if (!timestamp || Date.now() - timestamp > 300000 || timestamp > Date.now() + 60000) return Promise.resolve(null);
   let state = queues.get(conn);
@@ -58,7 +65,8 @@ function handleAutoViewOnce(raw, conn, settings = {}, options = {}) {
   state.seen.set(id, now); state.pending++;
   while (state.seen.size > 500) state.seen.delete(state.seen.keys().next().value);
   const task = state.tail.then(() => active() ? resendViewOnceMessage(conn, raw, { ...options, jid: chat, shouldSend: active }) : null);
-  state.tail = task.catch(() => {}).finally(() => { state.pending--; });
+  task.then(result => conn.ev?.emit('kage.automation', { kind: 'viewonce', id: raw.key.id, chat, outcome: result ? 'sent' : 'cancelled' }), error => conn.ev?.emit('kage.automation', { kind: 'viewonce', id: raw.key.id, chat, outcome: 'failed', error: String(error.message || error).slice(0,200) })).catch(error => conn.logger?.warn?.({ error: error.message }, 'automation event listener'));
+  state.tail = task.catch(() => { state.seen.delete(id); }).finally(() => { state.pending--; });
   return task;
 }
 exports.getViewOnceContent = getViewOnceContent;