@fer2809fl/baileys 7.0.2 → 7.0.5

package/lib/Utils/anti-ban.js

@@ -0,0 +1,182 @@
+import { randomBytes } from 'crypto';
+
+const ANTI_BAN_CONFIG = {
+    MIN_MESSAGE_DELAY: 300,
+    MAX_MESSAGE_DELAY: 800,
+    MIN_TYPING_DELAY: 500,
+    MAX_TYPING_DELAY: 1500,
+    GROUP_MESSAGE_DELAY: 500,
+    GROUP_MAX_MESSAGES_PER_MINUTE: 40,
+    BROADCAST_DELAY: 1500,
+    BROADCAST_MAX_PER_HOUR: 300,
+    PRESENCE_UPDATE_INTERVAL: 30000,
+    JITTER_PERCENT: 0.3
+};
+
+function randomDelay(min, max) {
+    const base = Math.floor(Math.random() * (max - min + 1)) + min;
+    const jitter = base * ANTI_BAN_CONFIG.JITTER_PERCENT * (Math.random() - 0.5);
+    return Math.max(min, Math.floor(base + jitter));
+}
+
+async function messageDelay(isGroup = false) {
+    const delay = isGroup
+        ? randomDelay(ANTI_BAN_CONFIG.GROUP_MESSAGE_DELAY, ANTI_BAN_CONFIG.GROUP_MESSAGE_DELAY * 2)
+        : randomDelay(ANTI_BAN_CONFIG.MIN_MESSAGE_DELAY, ANTI_BAN_CONFIG.MAX_MESSAGE_DELAY);
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+async function typingDelay(messageLength = 50) {
+    const wordsPerMinute = 50 + (Math.random() * 20 - 10);
+    const avgWordLength = 5;
+    const estimatedWords = messageLength / avgWordLength;
+    const typingTime = (estimatedWords / wordsPerMinute) * 60 * 1000;
+    const minDelay = ANTI_BAN_CONFIG.MIN_TYPING_DELAY;
+    const calculatedDelay = Math.max(minDelay, Math.min(typingTime, ANTI_BAN_CONFIG.MAX_TYPING_DELAY));
+    return new Promise(resolve => setTimeout(resolve, calculatedDelay));
+}
+
+class RateLimiter {
+    constructor(maxRequests, windowMs) {
+        this.maxRequests = maxRequests;
+        this.windowMs = windowMs;
+        this.requests = new Map();
+    }
+
+    canSend(jid) {
+        const now = Date.now();
+        const key = jid || 'global';
+        if (!this.requests.has(key)) this.requests.set(key, []);
+        const timestamps = this.requests.get(key);
+        const validTimestamps = timestamps.filter(ts => now - ts < this.windowMs);
+        this.requests.set(key, validTimestamps);
+        return validTimestamps.length < this.maxRequests;
+    }
+
+    recordSend(jid) {
+        const key = jid || 'global';
+        if (!this.requests.has(key)) this.requests.set(key, []);
+        this.requests.get(key).push(Date.now());
+    }
+
+    getWaitTime(jid) {
+        const key = jid || 'global';
+        if (!this.requests.has(key)) return 0;
+        const timestamps = this.requests.get(key);
+        if (timestamps.length < this.maxRequests) return 0;
+        const oldestValid = timestamps[timestamps.length - this.maxRequests];
+        const waitTime = this.windowMs - (Date.now() - oldestValid);
+        return Math.max(0, waitTime);
+    }
+
+    async waitForSlot(jid) {
+        const waitTime = this.getWaitTime(jid);
+        if (waitTime > 0) {
+            await new Promise(resolve => setTimeout(resolve, waitTime + randomDelay(100, 500)));
+        }
+        this.recordSend(jid);
+    }
+
+    cleanup() {
+        const now = Date.now();
+        for (const [key, timestamps] of this.requests.entries()) {
+            const valid = timestamps.filter(ts => now - ts < this.windowMs);
+            if (valid.length === 0) this.requests.delete(key);
+            else this.requests.set(key, valid);
+        }
+    }
+}
+
+class PresenceManager {
+    constructor(sock, logger) {
+        this.sock = sock;
+        this.logger = logger;
+        this.activeChats = new Set();
+        this.presenceInterval = null;
+    }
+
+    async simulatePresence(jid, action = 'composing') {
+        try {
+            await this.sock.sendPresenceUpdate(action, jid);
+            this.activeChats.add(jid);
+            setTimeout(() => {
+                this.activeChats.delete(jid);
+                this.sock.sendPresenceUpdate('paused', jid).catch(() => {});
+            }, randomDelay(3000, 8000));
+        } catch (error) {
+            this.logger?.debug({ error }, 'Error updating presence');
+        }
+    }
+
+    async sendWithPresence(jid, sendFunc, messageContent) {
+        await this.simulatePresence(jid, 'composing');
+        const length = typeof messageContent === 'string'
+            ? messageContent.length
+            : JSON.stringify(messageContent).length;
+        await typingDelay(length);
+        const result = await sendFunc();
+        setTimeout(() => {
+            this.sock.sendPresenceUpdate('paused', jid).catch(() => {});
+        }, randomDelay(500, 1500));
+        return result;
+    }
+
+    startPeriodicPresence() {
+        if (this.presenceInterval) return;
+        this.presenceInterval = setInterval(() => {
+            this.sock.sendPresenceUpdate('available').catch(() => {});
+        }, ANTI_BAN_CONFIG.PRESENCE_UPDATE_INTERVAL);
+    }
+
+    stopPeriodicPresence() {
+        if (this.presenceInterval) {
+            clearInterval(this.presenceInterval);
+            this.presenceInterval = null;
+        }
+    }
+}
+
+function generateSessionFingerprint() {
+    const timestamp = Date.now();
+    const random = randomBytes(8).toString('hex');
+    return `${timestamp}-${random}`;
+}
+
+function isValidJid(jid) {
+    if (!jid || typeof jid !== 'string') return false;
+    const patterns = [
+        /^\d+@s\.whatsapp\.net$/,
+        /^\d+-\d+@g\.us$/,
+        /^\d+@broadcast$/,
+        /^status@broadcast$/,
+        /^\d+@lid$/
+    ];
+    return patterns.some(pattern => pattern.test(jid));
+}
+
+function sanitizeMessage(text) {
+    if (!text || typeof text !== 'string') return text;
+    let sanitized = text.replace(/[\u200B-\u200D\uFEFF]/g, '');
+    sanitized = sanitized.replace(/\n{4,}/g, '\n\n\n');
+    sanitized = sanitized.replace(/ {3,}/g, '  ');
+    return sanitized.trim();
+}
+
+const globalRateLimiter = new RateLimiter(100, 60000);
+const groupRateLimiter = new RateLimiter(20, 60000);
+const broadcastRateLimiter = new RateLimiter(200, 3600000);
+
+export {
+    ANTI_BAN_CONFIG,
+    randomDelay,
+    messageDelay,
+    typingDelay,
+    RateLimiter,
+    PresenceManager,
+    generateSessionFingerprint,
+    isValidJid,
+    sanitizeMessage,
+    globalRateLimiter,
+    groupRateLimiter,
+    broadcastRateLimiter
+};

package/lib/Utils/banner.d.ts

@@ -0,0 +1,8 @@
+export declare const BAILEYS_LOGO: string[];
+
+export declare function printBanner(options?: {
+    stream?: NodeJS.WritableStream;
+    frameMs?: number;
+    once?: boolean;
+    animate?: boolean;
+}): Promise<void>;

package/lib/Utils/banner.js

@@ -0,0 +1,76 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const BAILEYS_LOGO = [
+    '               ⠠⡀ ⡀',
+    '              ⠱⣄⠘⣆',
+    '      ⣀  ⢢⣤⣀⣦⣄⡀⠙⣶⡘⢷⣄',
+    '    ⣀⣀⣨⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣯⣿⣷⣄',
+    '   ⢀⣽⣿⣿⣿⣿⠟⠛⠛⠛⠛⠻⢿⣿⣿⣿⣿⣿⣿⣷⣄',
+    '  ⠘⣻⣿⣿⡿⠋        ⠈⠙⢿⣿⣿⣿⣿⢿⣷⡀',
+    '  ⣴⣿⣿⣿⡇            ⠙⣿⣿⣿⣷⣽⣷⣄',
+    '   ⣾⣿⣿⣇             ⠈⠛⢿⣿⣿⣿⣯⠁',
+    '  ⠐⠛⢿⣿⣿⣦⡀              ⠉⠻⣿⣿⣷⣄⡀',
+    '    ⠘⠟⠿⣿⣿⣦⣀              ⠈⢿⣿⣿⠇',
+    '       ⠈⠙⠻⣿⣷⣦⣄⡀           ⡼⠟⠋',
+    '           ⠈⠙⠻⢿⣷⣶⣄',
+    '               ⠈⠙⠻⣿⣦⡀',
+    '                   ⠙⢿⡄',
+    '                     ⢻⡄',
+    '                     ⠈⡇'
+];
+
+const GRADIENT_FROM = [167, 85, 247];
+const GRADIENT_TO = [34, 211, 238];
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const supportsColor = stream => {
+    if (process.env.NO_COLOR || process.env.NODE_DISABLE_COLORS) return false;
+    if (process.env.FORCE_COLOR) return true;
+    return !!stream.isTTY;
+};
+
+const paint = (text, t) => {
+    const [r, g, b] = GRADIENT_FROM.map((from, i) => Math.round(from + (GRADIENT_TO[i] - from) * t));
+    return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+};
+
+const buildLines = version => [
+    '',
+    ...BAILEYS_LOGO,
+    '',
+    `   @fer2809fl/baileys   v${version}`,
+    '   github.com/Fer2809fl/Bail',
+    ''
+];
+
+let alreadyPrinted = false;
+
+const printBanner = async (options = {}) => {
+    let version = '2.0';
+    try {
+        const pkg = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8'));
+        version = pkg.version || version;
+    } catch {}
+    const {
+        stream = process.stdout,
+        frameMs = 45,
+        once = true
+    } = options;
+    if (once && alreadyPrinted) return;
+    alreadyPrinted = true;
+    const animate = options.animate !== undefined ? options.animate : !!stream.isTTY;
+    const color = supportsColor(stream);
+    const lines = buildLines(version);
+    for (let i = 0; i < lines.length; i++) {
+        const t = i / (lines.length - 1);
+        stream.write((color ? paint(lines[i], t) : lines[i]) + '\n');
+        if (animate) await sleep(frameMs);
+    }
+};
+
+export {
+    BAILEYS_LOGO,
+    printBanner
+};

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

@@ -0,0 +1,57 @@
+export declare function parseCommand(text: string, prefix?: string): {
+    isCommand: boolean;
+    command?: string;
+    args?: string[];
+    fullArgs?: string;
+    flags?: Record<string, string | boolean>;
+    raw?: string;
+    prefix?: string;
+};
+
+export declare function extractMentions(message: any): string[];
+export declare function extractText(message: any): string;
+export declare function extractQuotedMessage(message: any): {
+    message: any;
+    stanzaId?: string;
+    participant?: string;
+    remoteJid?: string;
+    text: string;
+} | null;
+
+export declare function isGroupAdmin(sock: any, jid: string, participantJid: string): Promise<boolean>;
+export declare function isBotAdmin(sock: any, jid: string): Promise<boolean>;
+export declare function getSenderJid(msg: any): string;
+export declare function formatJid(jid: string): string;
+export declare function generateMessageId(): string;
+export declare function truncateText(text: string, maxLength?: number, suffix?: string): string;
+export declare function escapeMarkdown(text: string): string;
+export declare function formatPhoneNumber(jid: string): string;
+
+export declare class CooldownManager {
+    isOnCooldown(key: string, cooldownMs: number): boolean;
+    setCooldown(key: string, cooldownMs: number): void;
+    getRemainingTime(key: string): number;
+    cleanup(): void;
+}
+
+export declare class PermissionManager {
+    constructor(config?: { owners?: string[]; admins?: string[]; banned?: string[]; premiums?: string[] });
+    isOwner(jid: string): boolean;
+    isAdmin(jid: string): boolean;
+    isBanned(jid: string): boolean;
+    isPremium(jid: string): boolean;
+    addOwner(jid: string): void;
+    removeOwner(jid: string): void;
+    addAdmin(jid: string): void;
+    removeAdmin(jid: string): void;
+    ban(jid: string): void;
+    unban(jid: string): void;
+    addPremium(jid: string): void;
+    removePremium(jid: string): void;
+    toJSON(): { owners: string[]; admins: string[]; banned: string[]; premiums: string[] };
+}
+
+export declare function createReply(options: { text: string; mentions?: string[]; quoted?: any }): { text: string; mentions?: string[]; quoted?: any };
+export declare function parseTime(timeStr: string): number;
+export declare function formatDuration(ms: number): string;
+export declare function sendFast(sock: any, jid: string, content: string | object, opts?: { quoted?: any; markRead?: boolean }): Promise<any>;

package/lib/Utils/bot-utils.js

@@ -0,0 +1,241 @@
+import { isJidGroup, jidDecode, jidNormalizedUser } from '../WABinary/index.js';
+import { randomBytes } from 'crypto';
+
+function parseCommand(text, prefix = '.') {
+    if (!text || typeof text !== 'string') return { isCommand: false };
+    const trimmed = text.trim();
+    if (!trimmed.startsWith(prefix)) return { isCommand: false };
+    const withoutPrefix = trimmed.slice(prefix.length);
+    const parts = withoutPrefix.split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    const fullArgs = withoutPrefix.slice(command.length).trim();
+    const flags = {};
+    const cleanArgs = [];
+    for (const arg of args) {
+        if (arg.startsWith('--')) {
+            const [key, value] = arg.slice(2).split('=');
+            flags[key] = value || true;
+        } else if (arg.startsWith('-') && arg.length === 2) {
+            flags[arg.slice(1)] = true;
+        } else {
+            cleanArgs.push(arg);
+        }
+    }
+    return { isCommand: true, command, args: cleanArgs, fullArgs, flags, raw: text, prefix };
+}
+
+function extractMentions(message) {
+    const mentions = [];
+    const extendedText = message.extendedTextMessage;
+    if (extendedText?.contextInfo?.mentionedJid) mentions.push(...extendedText.contextInfo.mentionedJid);
+    if (message.mentionedJid) mentions.push(...message.mentionedJid);
+    const text = extractText(message);
+    if (text) {
+        const phoneMatches = text.match(/@(\d+)/g);
+        if (phoneMatches) {
+            phoneMatches.forEach(match => {
+                const phone = match.slice(1);
+                const jid = `${phone}@s.whatsapp.net`;
+                if (!mentions.includes(jid)) mentions.push(jid);
+            });
+        }
+    }
+    return [...new Set(mentions)];
+}
+
+function extractText(message) {
+    if (!message) return '';
+    if (typeof message === 'string') return message;
+    const textSources = [
+        message.conversation,
+        message.extendedTextMessage?.text,
+        message.imageMessage?.caption,
+        message.videoMessage?.caption,
+        message.documentMessage?.caption,
+        message.buttonsResponseMessage?.selectedButtonId,
+        message.listResponseMessage?.singleSelectReply?.selectedRowId,
+        message.templateButtonReplyMessage?.selectedId
+    ];
+    return textSources.find(t => t) || '';
+}
+
+function extractQuotedMessage(message) {
+    const contextInfo =
+        message.extendedTextMessage?.contextInfo ||
+        message.imageMessage?.contextInfo ||
+        message.videoMessage?.contextInfo ||
+        message.documentMessage?.contextInfo ||
+        message.stickerMessage?.contextInfo;
+    if (!contextInfo?.quotedMessage) return null;
+    return {
+        message: contextInfo.quotedMessage,
+        stanzaId: contextInfo.stanzaId,
+        participant: contextInfo.participant,
+        remoteJid: contextInfo.remoteJid,
+        text: extractText(contextInfo.quotedMessage)
+    };
+}
+
+async function isGroupAdmin(sock, jid, participantJid) {
+    try {
+        if (!isJidGroup(jid)) return false;
+        const metadata = await sock.groupMetadata(jid);
+        const participant = metadata.participants.find(
+            p => jidNormalizedUser(p.id) === jidNormalizedUser(participantJid)
+        );
+        return participant?.admin === 'admin' || participant?.admin === 'superadmin';
+    } catch { return false; }
+}
+
+async function isBotAdmin(sock, jid) {
+    const botJid = sock.user?.id;
+    if (!botJid) return false;
+    return isGroupAdmin(sock, jid, botJid);
+}
+
+function getSenderJid(msg) {
+    const isGroup = isJidGroup(msg.key.remoteJid);
+    return isGroup ? msg.key.participant : msg.key.remoteJid;
+}
+
+function formatJid(jid) {
+    if (!jid) return 'Unknown';
+    const decoded = jidDecode(jid);
+    return decoded?.user || jid.split('@')[0] || jid;
+}
+
+function generateMessageId() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(8).toString('hex');
+    return `${timestamp}-${random}`.toUpperCase();
+}
+
+function truncateText(text, maxLength = 100, suffix = '...') {
+    if (!text || text.length <= maxLength) return text;
+    return text.slice(0, maxLength - suffix.length) + suffix;
+}
+
+function escapeMarkdown(text) {
+    if (!text) return '';
+    return text.replace(/([*_`\[\]()])/g, '\\$1');
+}
+
+function formatPhoneNumber(jid) {
+    const number = jid.replace(/[^0-9]/g, '');
+    if (number.length >= 10) {
+        const countryCode = number.slice(0, -10);
+        const areaCode = number.slice(-10, -7);
+        const first = number.slice(-7, -4);
+        const last = number.slice(-4);
+        return `+${countryCode} ${areaCode} ${first} ${last}`;
+    }
+    return number;
+}
+
+class CooldownManager {
+    constructor() { this.cooldowns = new Map(); }
+    isOnCooldown(key, cooldownMs) {
+        const expiry = this.cooldowns.get(key);
+        if (!expiry) return false;
+        if (Date.now() < expiry) return true;
+        this.cooldowns.delete(key);
+        return false;
+    }
+    setCooldown(key, cooldownMs) { this.cooldowns.set(key, Date.now() + cooldownMs); }
+    getRemainingTime(key) {
+        const expiry = this.cooldowns.get(key);
+        if (!expiry) return 0;
+        return Math.max(0, expiry - Date.now());
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, expiry] of this.cooldowns) {
+            if (now >= expiry) this.cooldowns.delete(key);
+        }
+    }
+}
+
+class PermissionManager {
+    constructor(config = {}) {
+        this.owners = new Set(config.owners || []);
+        this.admins = new Set(config.admins || []);
+        this.banned = new Set(config.banned || []);
+        this.premiums = new Set(config.premiums || []);
+    }
+    isOwner(jid) { return this.owners.has(jidNormalizedUser(jid)); }
+    isAdmin(jid) {
+        const normalized = jidNormalizedUser(jid);
+        return this.admins.has(normalized) || this.owners.has(normalized);
+    }
+    isBanned(jid) { return this.banned.has(jidNormalizedUser(jid)); }
+    isPremium(jid) { return this.premiums.has(jidNormalizedUser(jid)); }
+    addOwner(jid) { this.owners.add(jidNormalizedUser(jid)); }
+    removeOwner(jid) { this.owners.delete(jidNormalizedUser(jid)); }
+    addAdmin(jid) { this.admins.add(jidNormalizedUser(jid)); }
+    removeAdmin(jid) { this.admins.delete(jidNormalizedUser(jid)); }
+    ban(jid) { this.banned.add(jidNormalizedUser(jid)); }
+    unban(jid) { this.banned.delete(jidNormalizedUser(jid)); }
+    addPremium(jid) { this.premiums.add(jidNormalizedUser(jid)); }
+    removePremium(jid) { this.premiums.delete(jidNormalizedUser(jid)); }
+    toJSON() {
+        return { owners: [...this.owners], admins: [...this.admins], banned: [...this.banned], premiums: [...this.premiums] };
+    }
+}
+
+function createReply(options) {
+    const { text, mentions = [], quoted = null } = options;
+    const message = { text };
+    if (mentions.length > 0) message.mentions = mentions;
+    if (quoted) message.quoted = quoted;
+    return message;
+}
+
+function parseTime(timeStr) {
+    if (!timeStr || typeof timeStr !== 'string') return 0;
+    const units = { s: 1000, m: 60 * 1000, h: 60 * 60 * 1000, d: 24 * 60 * 60 * 1000, w: 7 * 24 * 60 * 60 * 1000 };
+    const match = timeStr.match(/^(\d+)([smhdw])$/i);
+    if (!match) return 0;
+    const value = parseInt(match[1]);
+    const unit = match[2].toLowerCase();
+    return value * (units[unit] || 0);
+}
+
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) return `${days}d ${hours % 24}h`;
+    if (hours > 0) return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+
+async function sendFast(sock, jid, content, opts = {}) {
+    const { quoted = null, markRead = false } = opts;
+    const message = typeof content === 'string' ? { text: content } : content;
+    if (markRead && quoted?.key) sock.readMessages([quoted.key]).catch(() => {});
+    return sock.sendMessage(jid, message, quoted ? { quoted } : {});
+}
+
+export {
+    parseCommand,
+    extractMentions,
+    extractText,
+    extractQuotedMessage,
+    isGroupAdmin,
+    isBotAdmin,
+    getSenderJid,
+    formatJid,
+    generateMessageId,
+    truncateText,
+    escapeMarkdown,
+    formatPhoneNumber,
+    CooldownManager,
+    PermissionManager,
+    createReply,
+    parseTime,
+    formatDuration,
+    sendFast
+};

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

@@ -6,13 +6,43 @@ type FetchAppStateSyncKey = (keyId: string) => Promise<proto.Message.IAppStateSy
 export type ChatMutationMap = {
     [index: string]: ChatMutation;
 };
+type Mac = {
+    indexMac: Uint8Array;
+    valueMac: Uint8Array;
+    operation: proto.SyncdMutation.SyncdOperation;
+};
+export declare const makeLtHashGenerator: ({ indexValueMap, hash }: Pick<LTHashState, "hash" | "indexValueMap">) => {
+    mix: ({ indexMac, valueMac, operation }: Mac) => void;
+    finish: () => {
+        hash: Buffer<ArrayBuffer>;
+        indexValueMap: {
+            [indexMacBase64: string]: {
+                valueMac: Uint8Array | Buffer;
+            };
+        };
+    };
+};
 export declare const newLTHashState: () => LTHashState;
+export declare const ensureLTHashStateVersion: (state: LTHashState) => LTHashState;
+export declare const MAX_SYNC_ATTEMPTS = 2;
+/**
+ * Check if an error is a missing app state sync key.
+ * WA Web treats these as "Blocked" (waits for key arrival), not fatal.
+ * In Baileys we retry with a snapshot which may use a different key.
+ */
+export declare const isMissingKeyError: (error: any) => boolean;
+/**
+ * Determines if an app state sync error is unrecoverable.
+ * TypeError indicates a WASM crash; otherwise we give up after MAX_SYNC_ATTEMPTS.
+ * Missing keys are NOT checked here — they are handled separately as "Blocked".
+ */
+export declare const isAppStateSyncIrrecoverable: (error: any, attempts: number) => boolean;
 export declare const encodeSyncdPatch: ({ type, index, syncAction, apiVersion, operation }: WAPatchCreate, myAppStateKeyId: string, state: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey) => Promise<{
     patch: proto.ISyncdPatch;
     state: LTHashState;
 }>;
 export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation | proto.ISyncdRecord)[], initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
-    hash: Buffer;
+    hash: Buffer<ArrayBuffer>;
     indexValueMap: {
         [indexMacBase64: string]: {
             valueMac: Uint8Array | Buffer;
@@ -20,7 +50,7 @@ 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: Buffer;
+    hash: Buffer<ArrayBuffer>;
     indexValueMap: {
         [indexMacBase64: string]: {
             valueMac: Uint8Array | Buffer;
@@ -54,9 +84,9 @@ export declare const extractSyncdPatches: (result: BinaryNode, options: RequestI
         snapshot?: proto.ISyncdSnapshot;
     };
 }>;
-export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: RequestInit) => Promise<Buffer>;
+export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: RequestInit) => Promise<Buffer<ArrayBuffer>>;
 export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: RequestInit) => Promise<proto.SyncdMutations>;
-export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
+export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean, logger?: ILogger) => Promise<{
     state: LTHashState;
     mutationMap: ChatMutationMap;
 }>;