@ikyyjee/ikyysinggle 1.7.7

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/lib/Utils/view-once-cache.js

@@ -0,0 +1,79 @@
+/**
+ * lib/Utils/view-once-cache.js — opt-in helper that saves view-once media
+ * (photos/videos/voice notes that WhatsApp normally lets you open only
+ * once) to a local folder as it comes in, before it disappears. You call
+ * this explicitly with a folder to use; it does nothing unless you wire it
+ * up yourself, and everything stays on your own disk.
+ */
+import path from 'path';
+import fs from 'fs';
+import { downloadMediaMessage, extractMessageContent } from './messages.js';
+import { extensionForMediaMessage } from './messages-media.js';
+
+const VIEW_ONCE_WRAPPER_KEYS = ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'];
+const VIEW_ONCE_INNER_KEYS = ['imageMessage', 'videoMessage', 'audioMessage'];
+
+export const getViewOnceContent = (message) => {
+    if (!message) {
+        return null;
+    }
+    const content = extractMessageContent(message);
+    if (!content) {
+        return null;
+    }
+    for (const wrapperKey of VIEW_ONCE_WRAPPER_KEYS) {
+        const wrapper = content[wrapperKey];
+        if (wrapper?.message) {
+            const inner = extractMessageContent(wrapper.message);
+            if (inner) {
+                return inner;
+            }
+        }
+    }
+    for (const key of VIEW_ONCE_INNER_KEYS) {
+        if (content[key]?.viewOnce) {
+            return { [key]: content[key] };
+        }
+    }
+    return null;
+};
+
+/**
+ * @param sock A connected socket (needs `sock.ev`, `sock.logger`, `sock.updateMediaMessage`).
+ * @param options.cacheDir Folder to save into (default './viewonce-cache').
+ * @param options.onCached Optional callback fired after each successful save.
+ * @returns a function that unregisters the listener when called.
+ */
+export const autoCacheViewOnceMedia = (sock, options = {}) => {
+    const cacheDir = options.cacheDir || './viewonce-cache';
+    const logger = options.logger || sock.logger;
+    if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    const handler = async ({ messages, type }) => {
+        if (type !== 'notify' && type !== 'append') {
+            return;
+        }
+        for (const msg of messages) {
+            try {
+                const viewOnceContent = getViewOnceContent(msg.message);
+                if (!viewOnceContent) {
+                    continue;
+                }
+                const mediaType = Object.keys(viewOnceContent)[0];
+                const buffer = await downloadMediaMessage(msg, 'buffer', {}, { logger, reuploadRequest: sock.updateMediaMessage });
+                const extension = extensionForMediaMessage(viewOnceContent) || 'bin';
+                const fileName = `${msg.key.id}.${extension}`;
+                const filePath = path.join(cacheDir, fileName);
+                fs.writeFileSync(filePath, buffer);
+                logger?.debug?.({ id: msg.key.id, filePath, mediaType }, 'cached view-once media');
+                options.onCached?.({ id: msg.key.id, jid: msg.key.remoteJid, filePath, type: mediaType });
+            }
+            catch (error) {
+                logger?.warn?.({ error, id: msg.key?.id }, 'failed to cache view-once media');
+            }
+        }
+    };
+    sock.ev.on('messages.upsert', handler);
+    return () => sock.ev.off('messages.upsert', handler);
+};

package/lib/Utils/voip-rekey.js

@@ -0,0 +1,25 @@
+/**
+ * lib/Utils/voip-rekey.js — decode the E2E rekey payload WhatsApp sends to
+ * rotate call/media encryption keys during a VOIP call. Pure protobuf
+ * decode, no network or crypto side effects of its own.
+ */
+import { proto } from '../../WAProto/index.js';
+
+const REKEY_TYPE_NAMES = {
+    [proto.RekeyKeyType.REKEY_KEY_AUDIO]: 'REKEY_KEY_AUDIO',
+    [proto.RekeyKeyType.REKEY_KEY_VIDEO]: 'REKEY_KEY_VIDEO',
+    [proto.RekeyKeyType.REKEY_KEY_APPDATA]: 'REKEY_KEY_APPDATA'
+};
+
+export const decodeE2eRekeyPayload = (buffer) => {
+    if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+        throw new TypeError('decodeE2eRekeyPayload: buffer must be Buffer or Uint8Array');
+    }
+    const decoded = proto.E2eRekeyPayload.decode(buffer);
+    return {
+        keys: (decoded.keys || []).map((entry) => ({
+            type: REKEY_TYPE_NAMES[entry.type] ?? entry.type,
+            key: entry.key ? Buffer.from(entry.key) : Buffer.alloc(0)
+        }))
+    };
+};

package/lib/Utils/warmup.js

@@ -0,0 +1,117 @@
+/**
+ * lib/Utils/warmup.js — "AntiBanned" fresh-number throttle
+ *
+ * What this is: a small, transparent daily-send-limit ramp for numbers that
+ * were only recently connected to this socket. Brand new WhatsApp numbers
+ * get flagged for review more easily if they suddenly send a lot of
+ * messages, so this throttle starts them at a low daily cap and increases
+ * it every day until it "graduates" to unlimited after `warmUpDays`.
+ *
+ * What this is NOT: this does not touch message content, timing jitter
+ * beyond a plain send delay, device/browser fingerprints, proxies, or
+ * anything that tries to make automated traffic look indistinguishable
+ * from a human. It only answers one question — "has this number sent a
+ * suspiciously large number of messages today for how new it is?" — and
+ * either delays or blocks the send if so. See README.md → "AntiBanned".
+ *
+ * "Fresh" vs "old" is decided purely from state you keep on your own end
+ * (see `existingState` below) — this module makes no WhatsApp API calls
+ * and reads no account data; it's just a local counter.
+ */
+
+export const DEFAULT_WARMUP_CONFIG = {
+    /** How many days of ramp-up before this number is treated as "old" (unlimited). */
+    warmUpDays: 7,
+    /** Max messages allowed on day 1. */
+    day1Limit: 20,
+    /** Daily limit is multiplied by this factor each subsequent day. */
+    growthFactor: 1.8,
+    /** If graduated but silent for this many hours, restart the ramp from day 1. */
+    inactivityThresholdHours: 24 * 3
+};
+
+export class NumberWarmUp {
+    /**
+     * @param config Partial<typeof DEFAULT_WARMUP_CONFIG>
+     * @param existingState Pass in `exportState()` from a previous run (e.g.
+     *   loaded alongside your auth state) so the ramp survives restarts.
+     *   Omit it and every process restart is treated as a fresh number.
+     */
+    constructor(config = {}, existingState) {
+        this.config = { ...DEFAULT_WARMUP_CONFIG, ...config };
+        this.state = existingState || this.freshState();
+    }
+
+    freshState() {
+        const now = Date.now();
+        return {
+            startedAt: now,
+            lastActiveAt: now,
+            dailyCounts: [],
+            graduated: false
+        };
+    }
+
+    getCurrentDay() {
+        return Math.floor((Date.now() - this.state.startedAt) / (24 * 60 * 60 * 1000));
+    }
+
+    checkInactivity() {
+        const hoursSinceActive = (Date.now() - this.state.lastActiveAt) / (60 * 60 * 1000);
+        if (this.state.graduated && hoursSinceActive > this.config.inactivityThresholdHours) {
+            this.state = this.freshState();
+        }
+    }
+
+    getDailyLimit() {
+        if (this.state.graduated) {
+            return Infinity;
+        }
+        const day = this.getCurrentDay();
+        if (day >= this.config.warmUpDays) {
+            this.state.graduated = true;
+            return Infinity;
+        }
+        return Math.round(this.config.day1Limit * Math.pow(this.config.growthFactor, day));
+    }
+
+    /** true = "old enough" or under today's limit; false = should be delayed/blocked. */
+    canSend() {
+        this.checkInactivity();
+        if (this.state.graduated) {
+            return true;
+        }
+        const day = this.getCurrentDay();
+        const sentToday = this.state.dailyCounts[day] || 0;
+        return sentToday < this.getDailyLimit();
+    }
+
+    /** Call once per message actually sent. */
+    record() {
+        const day = this.getCurrentDay();
+        while (this.state.dailyCounts.length <= day) {
+            this.state.dailyCounts.push(0);
+        }
+        this.state.dailyCounts[day]++;
+        this.state.lastActiveAt = Date.now();
+    }
+
+    getStatus() {
+        this.checkInactivity();
+        const day = this.getCurrentDay();
+        const sentToday = this.state.dailyCounts[day] || 0;
+        const limit = this.getDailyLimit();
+        return {
+            isFreshNumber: !this.state.graduated,
+            day: Math.min(day + 1, this.config.warmUpDays),
+            totalWarmUpDays: this.config.warmUpDays,
+            todayLimit: limit === Infinity ? null : limit,
+            todaySent: sentToday
+        };
+    }
+
+    /** Persist alongside your auth state so the ramp survives restarts. */
+    exportState() {
+        return { ...this.state, dailyCounts: [...this.state.dailyCounts] };
+    }
+}