zapo-js 0.1.2 → 0.3.0

package/dist/esm/client/coordinators/WaOfflineResumeCoordinator.js

@@ -0,0 +1,110 @@
+import { buildOfflineBatchNode } from '../../transport/node/builders/offline.js';
+import { toError } from '../../util/primitives.js';
+const WA_OFFLINE_RESUME = Object.freeze({
+    BATCH_SIZE: 200,
+    STANZA_TIMEOUT_MS: 60000
+});
+const WA_OFFLINE_RESUME_STATE = Object.freeze({
+    INIT: 'init',
+    RESUMING: 'resuming',
+    COMPLETE: 'complete'
+});
+export class WaOfflineResumeCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.runtime = options.runtime;
+        this.state = WA_OFFLINE_RESUME_STATE.INIT;
+        this.totalStanzas = 0;
+        this.pendingStanzas = 0;
+        this.stanzaTimeout = null;
+    }
+    get isComplete() {
+        return this.state === WA_OFFLINE_RESUME_STATE.COMPLETE;
+    }
+    get isResuming() {
+        return this.state === WA_OFFLINE_RESUME_STATE.RESUMING;
+    }
+    handleOfflinePreview(stanzaCount) {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.RESUMING;
+        this.totalStanzas = stanzaCount;
+        this.pendingStanzas = stanzaCount;
+        this.logger.info('offline resume started', {
+            totalStanzas: stanzaCount
+        });
+        this.runtime.emitOfflineResume({
+            status: 'resuming',
+            totalStanzas: stanzaCount,
+            remainingStanzas: stanzaCount,
+            forced: false
+        });
+        void this.sendOfflineBatch();
+        this.resetStanzaTimeout();
+    }
+    handleOfflineComplete(serverStanzaCount) {
+        if (this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+            return;
+        }
+        this.completeResume(false, serverStanzaCount);
+    }
+    trackOfflineStanza() {
+        if (this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+            return;
+        }
+        this.pendingStanzas = Math.max(0, this.pendingStanzas - 1);
+        this.resetStanzaTimeout();
+    }
+    reset() {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.INIT;
+        this.totalStanzas = 0;
+        this.pendingStanzas = 0;
+    }
+    completeResume(forced, serverStanzaCount) {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.COMPLETE;
+        this.logger.info('offline resume complete', {
+            totalStanzas: this.totalStanzas,
+            remainingStanzas: this.pendingStanzas,
+            serverStanzaCount,
+            forced
+        });
+        this.runtime.emitOfflineResume({
+            status: 'complete',
+            totalStanzas: this.totalStanzas,
+            remainingStanzas: this.pendingStanzas,
+            forced
+        });
+    }
+    async sendOfflineBatch() {
+        try {
+            await this.runtime.sendNode(buildOfflineBatchNode(WA_OFFLINE_RESUME.BATCH_SIZE));
+        }
+        catch (err) {
+            this.logger.warn('offline batch request failed', {
+                message: toError(err).message
+            });
+        }
+    }
+    resetStanzaTimeout() {
+        if (this.stanzaTimeout !== null) {
+            clearTimeout(this.stanzaTimeout);
+        }
+        this.stanzaTimeout = setTimeout(() => {
+            this.stanzaTimeout = null;
+            if (this.state === WA_OFFLINE_RESUME_STATE.RESUMING) {
+                this.logger.warn('offline resume forced complete due to stanza timeout', {
+                    totalStanzas: this.totalStanzas,
+                    remainingStanzas: this.pendingStanzas
+                });
+                this.completeResume(true);
+            }
+        }, WA_OFFLINE_RESUME.STANZA_TIMEOUT_MS);
+    }
+    clearTimers() {
+        if (this.stanzaTimeout !== null) {
+            clearTimeout(this.stanzaTimeout);
+            this.stanzaTimeout = null;
+        }
+    }
+}

package/dist/esm/client/coordinators/WaPassiveTasksCoordinator.js

@@ -7,6 +7,7 @@ export class WaPassiveTasksCoordinator {
     constructor(options) {
         this.logger = options.logger;
         this.signalStore = options.signalStore;
+        this.preKeyStore = options.preKeyStore;
         this.signalDigestSync = options.signalDigestSync;
         this.signalRotateKey = options.signalRotateKey;
         this.signedPreKeyRotationIntervalMs =
@@ -14,6 +15,8 @@ export class WaPassiveTasksCoordinator {
         this.signedPreKeyServerErrorBackoffMs =
             options.signedPreKeyServerErrorBackoffMs ?? SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS;
         this.runtime = options.runtime;
+        this.mobilePrimary = options.mobilePrimary ?? false;
+        this.appStateSync = options.appStateSync;
         this.passiveTasksPromise = null;
     }
     startPassiveTasksAfterConnect() {
@@ -31,6 +34,16 @@ export class WaPassiveTasksCoordinator {
             this.passiveTasksPromise = null;
         });
     }
+    async handlePreKeyLowNotification() {
+        await Promise.all([
+            this.preKeyStore.setServerHasPreKeys(false),
+            this.runtime.persistServerHasPreKeys(false)
+        ]);
+        await this.uploadPreKeysIfMissing(false);
+    }
+    async handleDigestNotification() {
+        await this.validateDigestAndRecoverPreKeys();
+    }
     resetInFlightState() {
         if (!this.passiveTasksPromise) {
             return;
@@ -44,14 +57,36 @@ export class WaPassiveTasksCoordinator {
             this.logger.trace('passive connect tasks skipped: session is not registered');
             return;
         }
-        await this.uploadPreKeysIfMissing();
-        await this.validateDigestAndRecoverPreKeys();
-        await this.rotateSignedPreKeyIfDue();
+        this.runtime.syncAbProps();
+        if (this.mobilePrimary && this.appStateSync) {
+            await this.appStateSync.ensureInitialSyncKey().catch((error) => {
+                this.logger.warn('app-state initial key generation failed', {
+                    message: toError(error).message
+                });
+            });
+        }
+        await this.runtime.sendPresenceAvailable().catch((error) => {
+            this.logger.warn('presence available send failed', {
+                message: toError(error).message
+            });
+        });
+        const [registrationInfo, signedPreKey, serverHasPreKeys, signedPreKeyRotationTs] = await Promise.all([
+            this.signalStore.getRegistrationInfo(),
+            this.signalStore.getSignedPreKey(),
+            this.preKeyStore.getServerHasPreKeys(),
+            this.signalStore.getSignedPreKeyRotationTs()
+        ]);
+        const prefetchedLocalKeyBundle = registrationInfo && signedPreKey ? { registrationInfo, signedPreKey } : null;
+        await this.uploadPreKeysIfMissing(serverHasPreKeys, prefetchedLocalKeyBundle);
+        await this.validateDigestAndRecoverPreKeys(prefetchedLocalKeyBundle);
+        await this.rotateSignedPreKeyIfDue(signedPreKeyRotationTs);
         await this.flushDanglingReceipts();
     }
-    async validateDigestAndRecoverPreKeys() {
+    async validateDigestAndRecoverPreKeys(prefetchedLocalKeyBundle) {
         try {
-            const validation = await this.signalDigestSync.validateLocalKeyBundle();
+            const validation = prefetchedLocalKeyBundle
+                ? await this.signalDigestSync.validateLocalKeyBundle(prefetchedLocalKeyBundle)
+                : await this.signalDigestSync.validateLocalKeyBundle();
             if (validation.valid) {
                 this.logger.debug('signal digest validated', {
                     preKeyCount: validation.preKeyCount
@@ -67,10 +102,10 @@ export class WaPassiveTasksCoordinator {
                 return;
             }
             await Promise.all([
-                this.signalStore.setServerHasPreKeys(false),
+                this.preKeyStore.setServerHasPreKeys(false),
                 this.runtime.persistServerHasPreKeys(false)
             ]);
-            await this.uploadPreKeysIfMissing();
+            await this.uploadPreKeysIfMissing(false, prefetchedLocalKeyBundle);
         }
         catch (error) {
             this.logger.warn('signal digest validation failed with exception', {
@@ -78,21 +113,19 @@ export class WaPassiveTasksCoordinator {
             });
         }
     }
-    async uploadPreKeysIfMissing() {
-        const serverHasPreKeys = await this.signalStore.getServerHasPreKeys();
+    async uploadPreKeysIfMissing(serverHasPreKeysHint, prefetchedLocalKeyBundle) {
+        const serverHasPreKeys = serverHasPreKeysHint ?? (await this.preKeyStore.getServerHasPreKeys());
         if (serverHasPreKeys) {
             this.logger.trace('prekey upload skipped: server already has prekeys');
             return;
         }
-        const [registrationInfo, signedPreKey] = await Promise.all([
-            this.signalStore.getRegistrationInfo(),
-            this.signalStore.getSignedPreKey()
-        ]);
-        if (!registrationInfo || !signedPreKey) {
+        const resolvedLocalKeyBundle = prefetchedLocalKeyBundle ?? (await this.resolveLocalKeyBundleFromStore());
+        if (!resolvedLocalKeyBundle) {
             this.logger.warn('prekey upload skipped: registration info is missing');
             return;
         }
-        const preKeys = await this.signalStore.getOrGenPreKeys(SIGNAL_UPLOAD_PREKEYS_COUNT, generatePreKeyPair);
+        const { registrationInfo, signedPreKey } = resolvedLocalKeyBundle;
+        const preKeys = await this.preKeyStore.getOrGenPreKeys(SIGNAL_UPLOAD_PREKEYS_COUNT, generatePreKeyPair);
         if (preKeys.length === 0) {
             throw new Error('no prekey available for upload');
         }
@@ -101,11 +134,12 @@ export class WaPassiveTasksCoordinator {
         const response = await this.runtime.queryWithContext('prekeys.upload', uploadNode, WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: preKeys.length,
             lastPreKeyId
-        });
+        }, this.mobilePrimary ? { useSystemId: true } : undefined);
         if (response.attrs.type === 'result') {
-            await this.signalStore.markKeyAsUploaded(lastPreKeyId);
+            // Mark uploaded key first so the serverHasPreKeys flag never commits ahead of local key progress.
+            await this.preKeyStore.markKeyAsUploaded(lastPreKeyId);
             await Promise.all([
-                this.signalStore.setServerHasPreKeys(true),
+                this.preKeyStore.setServerHasPreKeys(true),
                 this.runtime.persistServerHasPreKeys(true)
             ]);
             this.logger.info('uploaded prekeys to server', {
@@ -121,10 +155,12 @@ export class WaPassiveTasksCoordinator {
             errorText: failure.errorText
         });
     }
-    async rotateSignedPreKeyIfDue() {
+    async rotateSignedPreKeyIfDue(signedPreKeyRotationTsHint) {
         try {
             const nowMs = Date.now();
-            const lastRotationTs = await this.signalStore.getSignedPreKeyRotationTs();
+            const lastRotationTs = signedPreKeyRotationTsHint === undefined
+                ? await this.signalStore.getSignedPreKeyRotationTs()
+                : signedPreKeyRotationTsHint;
             if (lastRotationTs === null) {
                 await this.signalStore.setSignedPreKeyRotationTs(nowMs);
                 this.logger.trace('signal rotate key skipped on first run');
@@ -150,6 +186,16 @@ export class WaPassiveTasksCoordinator {
             });
         }
     }
+    async resolveLocalKeyBundleFromStore() {
+        const [registrationInfo, signedPreKey] = await Promise.all([
+            this.signalStore.getRegistrationInfo(),
+            this.signalStore.getSignedPreKey()
+        ]);
+        if (!registrationInfo || !signedPreKey) {
+            return null;
+        }
+        return { registrationInfo, signedPreKey };
+    }
     resolveRotationTimestamp(nowMs, errorCode) {
         if (errorCode !== undefined && errorCode >= 500) {
             const retryInMs = Math.min(this.signedPreKeyServerErrorBackoffMs, this.signedPreKeyRotationIntervalMs);
@@ -167,29 +213,44 @@ export class WaPassiveTasksCoordinator {
             return;
         }
         this.logger.info('flushing dangling receipts', { count: pending.length });
-        for (let index = 0; index < pending.length; index += 1) {
-            const node = pending[index];
-            try {
-                await this.runtime.sendNodeDirect(node);
+        let cursor = 0;
+        while (cursor < pending.length) {
+            const batchEnd = Math.min(cursor + 4, pending.length);
+            const promises = [];
+            for (let i = cursor; i < batchEnd; i += 1) {
+                promises.push(this.runtime.sendNodeDirect(pending[i]));
             }
-            catch (error) {
-                const normalized = toError(error);
+            const results = await Promise.allSettled(promises);
+            let transientCount = 0;
+            for (let i = 0; i < results.length; i += 1) {
+                const result = results[i];
+                if (result.status === 'fulfilled') {
+                    continue;
+                }
+                const node = pending[cursor + i];
+                const normalized = toError(result.reason);
                 if (this.runtime.shouldQueueDanglingReceipt(node, normalized)) {
-                    for (let restoreIndex = index; restoreIndex < pending.length; restoreIndex += 1) {
-                        this.runtime.requeueDanglingReceipt(pending[restoreIndex]);
-                    }
-                    this.logger.warn('stopped dangling receipt flush due transient send error', {
-                        remaining: pending.length - index,
+                    this.runtime.requeueDanglingReceipt(node);
+                    transientCount += 1;
+                }
+                else {
+                    this.logger.warn('dropping dangling receipt due non-retryable send error', {
+                        id: node.attrs.id,
+                        to: node.attrs.to,
                         message: normalized.message
                     });
-                    return;
                 }
-                this.logger.warn('dropping dangling receipt due non-retryable send error', {
-                    id: node.attrs.id,
-                    to: node.attrs.to,
-                    message: normalized.message
+            }
+            if (transientCount > 0) {
+                for (let i = batchEnd; i < pending.length; i += 1) {
+                    this.runtime.requeueDanglingReceipt(pending[i]);
+                }
+                this.logger.warn('stopped dangling receipt flush due transient send error', {
+                    remaining: transientCount + (pending.length - batchEnd)
                 });
+                return;
             }
+            cursor = batchEnd;
         }
         this.logger.info('dangling receipts flushed');
     }

package/dist/esm/client/coordinators/WaPrivacyCoordinator.js

@@ -0,0 +1,131 @@
+import { WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES } from '../../protocol/privacy.js';
+import { buildBlocklistChangeIq, buildGetBlocklistIq, buildGetPrivacyDisallowedListIq, buildGetPrivacySettingsIq, buildSetPrivacyCategoryIq } from '../../transport/node/builders/privacy.js';
+import { findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { assertIqResult } from '../../transport/node/query.js';
+const IGNORED_SERVER_CATEGORIES = new Set([
+    'pix',
+    'linked_profiles',
+    'stickers',
+    'dependentaccountmessages',
+    'cover_photo',
+    'dependent_account_calling',
+    'groupcreation'
+]);
+function isValidPrivacyValue(value) {
+    return (value !== WA_PRIVACY_VALUES.ERROR &&
+        Object.values(WA_PRIVACY_VALUES).includes(value));
+}
+function parsePrivacySettings(result) {
+    const privacyNode = findNodeChild(result, 'privacy');
+    if (!privacyNode) {
+        return {};
+    }
+    const settings = {};
+    const categories = getNodeChildrenByTag(privacyNode, WA_PRIVACY_TAGS.CATEGORY);
+    for (let i = 0; i < categories.length; i += 1) {
+        const node = categories[i];
+        const name = node.attrs.name;
+        const value = node.attrs.value;
+        if (!name || !value) {
+            continue;
+        }
+        if (IGNORED_SERVER_CATEGORIES.has(name)) {
+            continue;
+        }
+        if (!isValidPrivacyValue(value)) {
+            continue;
+        }
+        const settingName = WA_PRIVACY_CATEGORY_TO_SETTING[name];
+        if (settingName) {
+            settings[settingName] = value;
+        }
+    }
+    return settings;
+}
+function parseDisallowedList(result) {
+    const privacyNode = findNodeChild(result, 'privacy');
+    if (!privacyNode) {
+        return { jids: [] };
+    }
+    const listNode = findNodeChild(privacyNode, WA_PRIVACY_TAGS.LIST);
+    if (!listNode) {
+        return { jids: [] };
+    }
+    const dhash = listNode.attrs.dhash;
+    const userNodes = getNodeChildrenByTag(listNode, WA_PRIVACY_TAGS.USER);
+    const jids = new Array(userNodes.length);
+    let jidsCount = 0;
+    for (let i = 0; i < userNodes.length; i += 1) {
+        const jid = userNodes[i].attrs.jid;
+        if (jid) {
+            jids[jidsCount] = jid;
+            jidsCount += 1;
+        }
+    }
+    jids.length = jidsCount;
+    return { jids, dhash };
+}
+function parseBlocklist(result) {
+    const listNode = findNodeChild(result, 'list');
+    if (!listNode) {
+        return { jids: [] };
+    }
+    const dhash = listNode.attrs.dhash;
+    const itemNodes = getNodeChildren(listNode);
+    const jids = new Array(itemNodes.length);
+    let jidsCount = 0;
+    for (let i = 0; i < itemNodes.length; i += 1) {
+        const jid = itemNodes[i].attrs.jid;
+        if (jid) {
+            jids[jidsCount] = jid;
+            jidsCount += 1;
+        }
+    }
+    jids.length = jidsCount;
+    return { jids, dhash };
+}
+export function createPrivacyCoordinator(options) {
+    const { queryWithContext } = options;
+    return {
+        getPrivacySettings: async () => {
+            const node = buildGetPrivacySettingsIq();
+            const result = await queryWithContext('privacy.getSettings', node);
+            assertIqResult(result, 'privacy.getSettings');
+            return parsePrivacySettings(result);
+        },
+        setPrivacySetting: async (setting, value) => {
+            const category = WA_PRIVACY_SETTING_TO_CATEGORY[setting];
+            const node = buildSetPrivacyCategoryIq(category, value);
+            const result = await queryWithContext('privacy.setSetting', node, undefined, {
+                category,
+                value
+            });
+            assertIqResult(result, 'privacy.setSetting');
+        },
+        getDisallowedList: async (setting) => {
+            const category = WA_PRIVACY_SETTING_TO_CATEGORY[setting];
+            const node = buildGetPrivacyDisallowedListIq(category);
+            const result = await queryWithContext('privacy.getDisallowedList', node, undefined, {
+                category
+            });
+            assertIqResult(result, 'privacy.getDisallowedList');
+            return parseDisallowedList(result);
+        },
+        getBlocklist: async () => {
+            const node = buildGetBlocklistIq();
+            const result = await queryWithContext('privacy.getBlocklist', node);
+            assertIqResult(result, 'privacy.getBlocklist');
+            return parseBlocklist(result);
+        },
+        blockUser: async (jid) => {
+            const node = buildBlocklistChangeIq(jid, 'block');
+            const result = await queryWithContext('privacy.blockUser', node, undefined, { jid });
+            assertIqResult(result, 'privacy.blockUser');
+        },
+        unblockUser: async (jid) => {
+            const node = buildBlocklistChangeIq(jid, 'unblock');
+            const result = await queryWithContext('privacy.unblockUser', node, undefined, { jid });
+            assertIqResult(result, 'privacy.unblockUser');
+        }
+    };
+}

package/dist/esm/client/coordinators/WaProfileCoordinator.js

@@ -0,0 +1,211 @@
+import { buildDeleteProfilePictureIq, buildGetDisappearingModeUsyncQueryNode, buildGetProfilePictureIq, buildGetStatusUsyncQueryNodes, buildSetProfilePictureIq, buildSetStatusIq } from '../../transport/node/builders/profile.js';
+import { buildUsyncIq } from '../../transport/node/builders/usync.js';
+import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { assertIqResult } from '../../transport/node/query.js';
+import { TEXT_DECODER } from '../../util/bytes.js';
+function parseProfilePicture(result) {
+    const pictureNode = findNodeChild(result, 'picture');
+    if (!pictureNode) {
+        return {};
+    }
+    return {
+        url: pictureNode.attrs.url,
+        directPath: pictureNode.attrs.direct_path,
+        id: pictureNode.attrs.id,
+        type: pictureNode.attrs.type
+    };
+}
+function parseSetPictureResult(result) {
+    const pictureNode = findNodeChild(result, 'picture');
+    return pictureNode?.attrs.id ?? null;
+}
+function parseUsyncProfiles(result) {
+    const usyncNode = findNodeChild(result, 'usync');
+    if (!usyncNode) {
+        return [];
+    }
+    const listNode = findNodeChild(usyncNode, 'list');
+    if (!listNode) {
+        return [];
+    }
+    const userNodes = getNodeChildren(listNode);
+    const profiles = new Array(userNodes.length);
+    let count = 0;
+    for (let i = 0; i < userNodes.length; i += 1) {
+        const userNode = userNodes[i];
+        if (userNode.tag !== 'user') {
+            continue;
+        }
+        const jid = userNode.attrs.jid;
+        if (!jid) {
+            continue;
+        }
+        const info = { jid };
+        const userContent = userNode.content;
+        if (!Array.isArray(userContent)) {
+            profiles[count] = info;
+            count += 1;
+            continue;
+        }
+        for (let j = 0; j < userContent.length; j += 1) {
+            const child = userContent[j];
+            if (child.tag === 'picture') {
+                const idAttr = child.attrs.id;
+                if (idAttr) {
+                    const parsed = Number.parseInt(idAttr, 10);
+                    if (Number.isSafeInteger(parsed)) {
+                        info.pictureId = parsed;
+                    }
+                }
+            }
+            else if (child.tag === 'status') {
+                const code = child.attrs.code;
+                if (code !== undefined && Number.parseInt(code, 10) === 401) {
+                    info.status = '';
+                }
+                else {
+                    const content = child.content;
+                    if (content instanceof Uint8Array) {
+                        const decoded = TEXT_DECODER.decode(content);
+                        info.status = decoded.length > 0 ? decoded : null;
+                    }
+                    else if (typeof content === 'string') {
+                        info.status = content.length > 0 ? content : null;
+                    }
+                    else {
+                        info.status = null;
+                    }
+                }
+            }
+        }
+        profiles[count] = info;
+        count += 1;
+    }
+    profiles.length = count;
+    return profiles;
+}
+function parseUsyncDisappearingModes(result) {
+    const usyncNode = findNodeChild(result, 'usync');
+    if (!usyncNode)
+        return [];
+    const listNode = findNodeChild(usyncNode, 'list');
+    if (!listNode)
+        return [];
+    const userNodes = getNodeChildren(listNode);
+    const results = new Array(userNodes.length);
+    let count = 0;
+    for (let i = 0; i < userNodes.length; i += 1) {
+        const userNode = userNodes[i];
+        if (userNode.tag !== 'user')
+            continue;
+        const userContent = userNode.content;
+        if (!Array.isArray(userContent))
+            continue;
+        for (let j = 0; j < userContent.length; j += 1) {
+            const child = userContent[j];
+            if (child.tag !== 'disappearing_mode')
+                continue;
+            const errorNode = findNodeChild(child, 'error');
+            if (errorNode)
+                continue;
+            const duration = Number.parseInt(child.attrs.duration ?? '0', 10);
+            const timestamp = Number.parseInt(child.attrs.t ?? '0', 10);
+            const entry = { duration, timestamp };
+            if (child.attrs.ephemerality_disabled === 'true') {
+                entry.ephemeralityDisabled = true;
+            }
+            results[count] = entry;
+            count += 1;
+        }
+    }
+    results.length = count;
+    return results;
+}
+function parseUsyncStatus(result) {
+    const profiles = parseUsyncProfiles(result);
+    if (profiles.length === 0) {
+        return { status: null };
+    }
+    return { status: profiles[0].status ?? null };
+}
+export function createProfileCoordinator(options) {
+    const { queryWithContext, generateSid } = options;
+    return {
+        getProfilePicture: async (jid, type, existingId) => {
+            const node = buildGetProfilePictureIq(jid, type, existingId);
+            const result = await queryWithContext('profile.getPicture', node, undefined, {
+                jid,
+                type: type ?? 'preview'
+            });
+            assertIqResult(result, 'profile.getPicture');
+            return parseProfilePicture(result);
+        },
+        setProfilePicture: async (imageBytes, targetJid) => {
+            const node = buildSetProfilePictureIq(imageBytes, targetJid);
+            const result = await queryWithContext('profile.setPicture', node, undefined, {
+                targetJid,
+                size: imageBytes.length
+            });
+            assertIqResult(result, 'profile.setPicture');
+            return parseSetPictureResult(result);
+        },
+        deleteProfilePicture: async (targetJid) => {
+            const node = buildDeleteProfilePictureIq(targetJid);
+            const result = await queryWithContext('profile.deletePicture', node, undefined, {
+                targetJid
+            });
+            assertIqResult(result, 'profile.deletePicture');
+        },
+        getStatus: async (jid) => {
+            const sid = await generateSid();
+            const queryNodes = buildGetStatusUsyncQueryNodes();
+            const usyncNode = buildUsyncIq({
+                sid,
+                queryProtocolNodes: [queryNodes[1]],
+                users: [{ jid }]
+            });
+            const result = await queryWithContext('profile.getStatus', usyncNode, undefined, {
+                jid
+            });
+            assertIqResult(result, 'profile.getStatus');
+            return parseUsyncStatus(result);
+        },
+        setStatus: async (text) => {
+            const node = buildSetStatusIq(text);
+            const result = await queryWithContext('profile.setStatus', node, undefined, undefined, {
+                useSystemId: true
+            });
+            assertIqResult(result, 'profile.setStatus');
+        },
+        getProfiles: async (jids) => {
+            if (jids.length === 0) {
+                return [];
+            }
+            const sid = await generateSid();
+            const queryProtocolNodes = buildGetStatusUsyncQueryNodes();
+            const usyncNode = buildUsyncIq({
+                sid,
+                queryProtocolNodes,
+                users: jids.map((jid) => ({ jid }))
+            });
+            const result = await queryWithContext('profile.getProfiles', usyncNode, undefined, {
+                count: jids.length
+            });
+            assertIqResult(result, 'profile.getProfiles');
+            return parseUsyncProfiles(result);
+        },
+        getDisappearingMode: async (jids) => {
+            if (jids.length === 0)
+                return [];
+            const sid = await generateSid();
+            const usyncNode = buildUsyncIq({
+                sid,
+                queryProtocolNodes: [buildGetDisappearingModeUsyncQueryNode()],
+                users: jids.map((jid) => ({ jid }))
+            });
+            const result = await queryWithContext('profile.getDisappearingMode', usyncNode, undefined, { count: jids.length });
+            assertIqResult(result, 'profile.getDisappearingMode');
+            return parseUsyncDisappearingModes(result);
+        }
+    };
+}