zapo-js 0.1.0

package/dist/esm/client/WaClientFactory.js

@@ -0,0 +1,377 @@
+import { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient.js';
+import { WaAuthClient } from '../auth/WaAuthClient.js';
+import { createGroupCoordinator } from './coordinators/WaGroupCoordinator.js';
+import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordinator.js';
+import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator.js';
+import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator.js';
+import { WaRetryCoordinator } from './coordinators/WaRetryCoordinator.js';
+import { createStreamControlHandler } from './coordinators/WaStreamControlCoordinator.js';
+import { handleDirtyBits, parseDirtyBits } from './dirty.js';
+import { buildMediaMessageContent, getMediaConn as getClientMediaConn } from './messages.js';
+import { WaMediaTransferClient } from '../media/WaMediaTransferClient.js';
+import { handleIncomingMessageAck } from '../message/incoming.js';
+import { WaMessageClient } from '../message/WaMessageClient.js';
+import { getWaCompanionPlatformId, WA_DEFAULTS } from '../protocol/constants.js';
+import { SignalDeviceSyncApi } from '../signal/api/SignalDeviceSyncApi.js';
+import { SignalDigestSyncApi } from '../signal/api/SignalDigestSyncApi.js';
+import { SignalIdentitySyncApi } from '../signal/api/SignalIdentitySyncApi.js';
+import { SignalMissingPreKeysSyncApi } from '../signal/api/SignalMissingPreKeysSyncApi.js';
+import { SignalRotateKeyApi } from '../signal/api/SignalRotateKeyApi.js';
+import { SignalSessionSyncApi } from '../signal/api/SignalSessionSyncApi.js';
+import { SenderKeyManager } from '../signal/group/SenderKeyManager.js';
+import { SignalProtocol } from '../signal/session/SignalProtocol.js';
+import { WaKeepAlive } from '../transport/keepalive/WaKeepAlive.js';
+import { WaNodeOrchestrator } from '../transport/node/WaNodeOrchestrator.js';
+import { WaNodeTransport } from '../transport/node/WaNodeTransport.js';
+import { toError } from '../util/primitives.js';
+import { getRuntimeOsDisplayName } from '../util/runtime.js';
+export function resolveWaClientBase(options, logger) {
+    const deviceBrowser = options.deviceBrowser ?? WA_DEFAULTS.DEVICE_BROWSER;
+    const sessionId = options.sessionId.trim();
+    if (sessionId.length === 0) {
+        throw new Error('sessionId must be a non-empty string');
+    }
+    const sessionStore = options.store.session(sessionId);
+    const normalizedOptions = Object.freeze({
+        ...options,
+        sessionId,
+        deviceBrowser,
+        deviceOsDisplayName: options.deviceOsDisplayName ?? getRuntimeOsDisplayName(),
+        devicePlatform: options.devicePlatform ?? getWaCompanionPlatformId(deviceBrowser),
+        urls: options.urls ?? options.chatSocketUrls ?? WA_DEFAULTS.CHAT_SOCKET_URLS,
+        iqTimeoutMs: options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS,
+        nodeQueryTimeoutMs: options.nodeQueryTimeoutMs ?? WA_DEFAULTS.NODE_QUERY_TIMEOUT_MS,
+        keepAliveIntervalMs: options.keepAliveIntervalMs ?? WA_DEFAULTS.HEALTH_CHECK_INTERVAL_MS,
+        deadSocketTimeoutMs: options.deadSocketTimeoutMs ?? WA_DEFAULTS.DEAD_SOCKET_TIMEOUT_MS,
+        mediaTimeoutMs: options.mediaTimeoutMs ?? WA_DEFAULTS.MEDIA_TIMEOUT_MS,
+        appStateSyncTimeoutMs: options.appStateSyncTimeoutMs ?? WA_DEFAULTS.APP_STATE_SYNC_TIMEOUT_MS,
+        signalFetchKeyBundlesTimeoutMs: options.signalFetchKeyBundlesTimeoutMs ??
+            WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS,
+        messageAckTimeoutMs: options.messageAckTimeoutMs ?? WA_DEFAULTS.MESSAGE_ACK_TIMEOUT_MS,
+        messageMaxAttempts: options.messageMaxAttempts ?? WA_DEFAULTS.MESSAGE_MAX_ATTEMPTS,
+        messageRetryDelayMs: options.messageRetryDelayMs ?? WA_DEFAULTS.MESSAGE_RETRY_DELAY_MS
+    });
+    return {
+        options: normalizedOptions,
+        logger,
+        sessionStore
+    };
+}
+function createAuthClient(input) {
+    const { options, logger, sessionStore, host } = input;
+    return new WaAuthClient({
+        deviceBrowser: options.deviceBrowser,
+        deviceOsDisplayName: options.deviceOsDisplayName,
+        devicePlatform: options.devicePlatform,
+        requireFullSync: options.requireFullSync
+    }, {
+        logger,
+        authStore: sessionStore.auth,
+        signalStore: sessionStore.signal,
+        socket: {
+            sendNode: host.sendNode,
+            query: host.query
+        },
+        callbacks: {
+            onQr: (qr, ttlMs) => host.emitEvent('auth_qr', { qr, ttlMs }),
+            onPairingCode: (code) => host.emitEvent('auth_pairing_code', { code }),
+            onPairingRefresh: (forceManual) => host.emitEvent('auth_pairing_refresh', { forceManual }),
+            onPaired: (credentials) => {
+                host.emitEvent('auth_paired', { credentials });
+                host.scheduleReconnectAfterPairing();
+            },
+            onError: (error) => host.handleError(error)
+        }
+    });
+}
+function createCurrentAuthGetters(authClient) {
+    const getCurrentCredentials = () => authClient.getCurrentCredentials();
+    return {
+        getCurrentCredentials,
+        getCurrentMeJid: () => getCurrentCredentials()?.meJid,
+        getCurrentMeLid: () => getCurrentCredentials()?.meLid,
+        getCurrentSignedIdentity: () => getCurrentCredentials()?.signedIdentity
+    };
+}
+function createIncomingMessageAckOptions(input) {
+    const { logger, host, getCurrentMeJid, signalProtocol, senderKeyManager, retryCoordinator } = input;
+    return {
+        logger,
+        sendNode: host.sendNode,
+        getMeJid: getCurrentMeJid,
+        signalProtocol,
+        senderKeyManager,
+        onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
+        emitIncomingMessage: (event) => {
+            void host
+                .handleIncomingMessageEvent(event)
+                .catch((err) => host.handleError(toError(err)));
+        },
+        emitUnhandledStanza: (event) => host.emitEvent('stanza_unhandled', event)
+    };
+}
+function createHandleClientDirtyBits(input) {
+    const { logger, host, getCurrentCredentials } = input;
+    return (dirtyBits) => handleDirtyBits({
+        logger,
+        queryWithContext: host.queryWithContext,
+        getCurrentCredentials,
+        syncAppState: host.syncAppState
+    }, dirtyBits);
+}
+function createIncomingNodeRuntime(input) {
+    const { logger, host, authClient, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, getCurrentMeJid, handleClientDirtyBits, incomingMessageAckOptions } = input;
+    return {
+        handleStreamControlResult: streamControl.handleStreamControlResult,
+        persistSuccessAttributes: (attributes) => authClient.persistSuccessAttributes(attributes),
+        emitSuccessNode: (node) => host.emitEvent('connection_success', { node }),
+        updateClockSkewFromSuccess: host.updateClockSkewFromSuccess,
+        shouldWarmupMediaConn: () => {
+            const comms = host.getComms();
+            return !!(getCurrentMeJid() && comms && comms.getCommsState().connected);
+        },
+        warmupMediaConn: async () => {
+            await getClientMediaConn(mediaMessageBuildOptions, true);
+        },
+        persistRoutingInfo: (routingInfo) => authClient.persistRoutingInfo(routingInfo),
+        tryResolvePendingNode: (node) => nodeOrchestrator.tryResolvePending(node),
+        handleGenericIncomingNode: (node) => nodeOrchestrator.handleIncomingNode(node),
+        handleIncomingIqSetNode: (node) => authClient.handleIncomingIqSet(node),
+        handleLinkCodeNotificationNode: (node) => authClient.handleLinkCodeNotification(node),
+        handleCompanionRegRefreshNotificationNode: (node) => authClient.handleCompanionRegRefreshNotification(node),
+        handleIncomingMessageNode: (node) => handleIncomingMessageAck(node, incomingMessageAckOptions),
+        sendNode: host.sendNode,
+        handleIncomingRetryReceipt: (node) => retryCoordinator.handleIncomingRetryReceipt(node),
+        trackOutboundReceipt: (node) => retryCoordinator.trackOutboundReceipt(node),
+        emitIncomingReceipt: (event) => host.emitEvent('message_receipt', event),
+        emitIncomingPresence: (event) => host.emitEvent('presence', event),
+        emitIncomingChatstate: (event) => host.emitEvent('chatstate', event),
+        emitIncomingCall: (event) => host.emitEvent('call', event),
+        emitIncomingFailure: (event) => host.emitEvent('failure', event),
+        emitIncomingErrorStanza: (event) => host.emitEvent('stanza_error', event),
+        emitIncomingNotification: (event) => host.emitEvent('notification', event),
+        emitGroupEvent: (event) => {
+            host.emitEvent('group_event', event);
+            void messageDispatch.mutateParticipantsCacheFromGroupEvent(event).catch((error) => {
+                logger.warn('failed to mutate participants cache from group event', {
+                    action: event.action,
+                    groupJid: event.groupJid,
+                    contextGroupJid: event.contextGroupJid,
+                    message: toError(error).message
+                });
+            });
+        },
+        emitUnhandledIncomingNode: (event) => host.emitEvent('stanza_unhandled', event),
+        syncAppState: host.syncAppState,
+        disconnect: host.disconnect,
+        clearStoredCredentials: host.clearStoredState,
+        parseDirtyBits: (nodes) => parseDirtyBits(nodes, logger),
+        handleDirtyBits: (dirtyBits) => handleClientDirtyBits(dirtyBits)
+    };
+}
+function createPassiveTasksRuntime(input) {
+    const { host, authClient, nodeOrchestrator, getCurrentCredentials } = input;
+    return {
+        queryWithContext: host.queryWithContext,
+        getCurrentCredentials,
+        persistServerHasPreKeys: (serverHasPreKeys) => authClient.persistServerHasPreKeys(serverHasPreKeys),
+        sendNodeDirect: (node) => nodeOrchestrator.sendNode(node),
+        takeDanglingReceipts: host.takeDanglingReceipts,
+        requeueDanglingReceipt: host.enqueueDanglingReceipt,
+        shouldQueueDanglingReceipt: host.shouldQueueDanglingReceipt
+    };
+}
+export function buildWaClientDependencies(input) {
+    const { base, host } = input;
+    const { options, logger, sessionStore } = base;
+    const nodeTransport = new WaNodeTransport(logger);
+    const nodeOrchestrator = new WaNodeOrchestrator({
+        sendNode: async (node) => nodeTransport.sendNode(node),
+        logger,
+        defaultTimeoutMs: options.nodeQueryTimeoutMs,
+        hostDomain: WA_DEFAULTS.HOST_DOMAIN
+    });
+    const keepAlive = new WaKeepAlive({
+        logger,
+        nodeOrchestrator,
+        getComms: host.getComms,
+        intervalMs: options.keepAliveIntervalMs,
+        timeoutMs: options.deadSocketTimeoutMs,
+        hostDomain: WA_DEFAULTS.HOST_DOMAIN
+    });
+    const mediaTransfer = new WaMediaTransferClient({
+        logger,
+        defaultTimeoutMs: options.mediaTimeoutMs
+    });
+    const mediaMessageBuildOptions = {
+        logger,
+        mediaTransfer,
+        iqTimeoutMs: options.iqTimeoutMs,
+        queryWithContext: host.queryWithContext,
+        getMediaConnCache: host.getMediaConnCache,
+        setMediaConnCache: host.setMediaConnCache
+    };
+    const messageClient = new WaMessageClient({
+        logger,
+        sendNode: host.sendNode,
+        query: host.query,
+        defaultAckTimeoutMs: options.messageAckTimeoutMs,
+        defaultMaxAttempts: options.messageMaxAttempts,
+        defaultRetryDelayMs: options.messageRetryDelayMs
+    });
+    const senderKeyManager = new SenderKeyManager(sessionStore.senderKey);
+    const signalProtocol = new SignalProtocol(sessionStore.signal, logger);
+    const signalDigestSync = new SignalDigestSyncApi({
+        logger,
+        query: host.query,
+        signalStore: sessionStore.signal,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalDeviceSync = new SignalDeviceSyncApi({
+        logger,
+        query: host.query,
+        deviceListStore: sessionStore.deviceList,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalIdentitySync = new SignalIdentitySyncApi({
+        logger,
+        query: host.query,
+        signalStore: sessionStore.signal,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalMissingPreKeysSync = new SignalMissingPreKeysSyncApi({
+        logger,
+        query: host.query,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalRotateKey = new SignalRotateKeyApi({
+        logger,
+        query: host.query,
+        signalStore: sessionStore.signal,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const signalSessionSync = new SignalSessionSyncApi({
+        logger,
+        query: host.query,
+        defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
+    });
+    const authClient = createAuthClient({ options, logger, sessionStore, host });
+    const { getCurrentCredentials, getCurrentMeJid, getCurrentMeLid, getCurrentSignedIdentity } = createCurrentAuthGetters(authClient);
+    const groupCoordinator = createGroupCoordinator({
+        queryWithContext: host.queryWithContext
+    });
+    const messageDispatch = new WaMessageDispatchCoordinator({
+        logger,
+        messageClient,
+        retryStore: sessionStore.retry,
+        participantsStore: sessionStore.participants,
+        buildMessageContent: async (content) => buildMediaMessageContent(mediaMessageBuildOptions, content),
+        queryGroupParticipantJids: async (groupJid) => (await groupCoordinator.queryGroupMetadata(groupJid)).participants.map((participant) => participant.jid),
+        senderKeyManager,
+        signalProtocol,
+        signalStore: sessionStore.signal,
+        signalDeviceSync,
+        signalIdentitySync,
+        signalSessionSync,
+        getCurrentMeJid,
+        getCurrentMeLid,
+        getCurrentSignedIdentity
+    });
+    const retryCoordinator = new WaRetryCoordinator({
+        logger,
+        retryStore: sessionStore.retry,
+        signalStore: sessionStore.signal,
+        senderKeyStore: sessionStore.senderKey,
+        signalProtocol,
+        signalDeviceSync,
+        signalMissingPreKeysSync,
+        messageClient,
+        sendNode: host.sendNode,
+        getCurrentMeJid,
+        getCurrentMeLid,
+        getCurrentSignedIdentity
+    });
+    const appStateSync = new WaAppStateSyncClient({
+        logger,
+        query: host.query,
+        defaultTimeoutMs: options.appStateSyncTimeoutMs,
+        store: sessionStore.appState,
+        onMissingKeys: async ({ keyIds }) => {
+            await messageDispatch.requestAppStateSyncKeys(keyIds);
+        }
+    });
+    const streamControl = createStreamControlHandler({
+        logger,
+        getComms: host.getComms,
+        clearPendingQueries: (error) => nodeOrchestrator.clearPending(error),
+        clearMediaConnCache: () => host.setMediaConnCache(null),
+        disconnect: host.disconnect,
+        clearStoredCredentials: host.clearStoredState,
+        connect: host.connect
+    });
+    const incomingMessageAckOptions = createIncomingMessageAckOptions({
+        logger,
+        host,
+        getCurrentMeJid,
+        signalProtocol,
+        senderKeyManager,
+        retryCoordinator
+    });
+    const handleClientDirtyBits = createHandleClientDirtyBits({
+        logger,
+        host,
+        getCurrentCredentials
+    });
+    const incomingNode = new WaIncomingNodeCoordinator({
+        logger,
+        runtime: createIncomingNodeRuntime({
+            logger,
+            host,
+            authClient,
+            nodeOrchestrator,
+            streamControl,
+            mediaMessageBuildOptions,
+            retryCoordinator,
+            messageDispatch,
+            getCurrentMeJid,
+            handleClientDirtyBits,
+            incomingMessageAckOptions
+        })
+    });
+    const passiveTasks = new WaPassiveTasksCoordinator({
+        logger,
+        signalStore: sessionStore.signal,
+        signalDigestSync,
+        signalRotateKey,
+        runtime: createPassiveTasksRuntime({
+            host,
+            authClient,
+            nodeOrchestrator,
+            getCurrentCredentials
+        })
+    });
+    return {
+        nodeTransport,
+        nodeOrchestrator,
+        keepAlive,
+        mediaTransfer,
+        mediaMessageBuildOptions,
+        messageClient,
+        senderKeyManager,
+        signalProtocol,
+        signalDigestSync,
+        signalDeviceSync,
+        signalIdentitySync,
+        signalMissingPreKeysSync,
+        signalRotateKey,
+        signalSessionSync,
+        authClient,
+        messageDispatch,
+        retryCoordinator,
+        appStateSync,
+        streamControl,
+        incomingNode,
+        passiveTasks,
+        groupCoordinator
+    };
+}

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

@@ -0,0 +1,188 @@
+import { WA_DEFAULTS } from '../../protocol/defaults.js';
+import { WA_GROUP_PARTICIPANT_TYPES } from '../../protocol/group.js';
+import { WA_NODE_TAGS, WA_XMLNS } from '../../protocol/nodes.js';
+import { buildCreateGroupIq, buildGroupParticipantChangeIq, buildLeaveGroupIq } from '../../transport/node/builders/group.js';
+import { findNodeChild, getNodeChildren, getNodeChildrenByTag, hasNodeChild } from '../../transport/node/helpers.js';
+import { assertIqResult, buildIqNode } from '../../transport/node/query.js';
+function parseGroupParticipants(node) {
+    const participantNodes = getNodeChildrenByTag(node, WA_NODE_TAGS.PARTICIPANT);
+    return participantNodes.map((p) => {
+        const type = p.attrs.type ?? WA_GROUP_PARTICIPANT_TYPES.REGULAR;
+        return {
+            jid: p.attrs.jid,
+            type,
+            isAdmin: type === WA_GROUP_PARTICIPANT_TYPES.ADMIN ||
+                type === WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN,
+            isSuperAdmin: type === WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN
+        };
+    });
+}
+function parseGroupMetadata(node) {
+    const groupNode = node.tag === WA_NODE_TAGS.GROUP ? node : findNodeChild(node, WA_NODE_TAGS.GROUP);
+    const target = groupNode ?? node;
+    const attrs = target.attrs;
+    const descNode = findNodeChild(target, WA_NODE_TAGS.DESCRIPTION);
+    let desc;
+    if (descNode) {
+        const bodyNode = findNodeChild(descNode, WA_NODE_TAGS.BODY);
+        if (bodyNode && typeof bodyNode.content === 'string') {
+            desc = bodyNode.content;
+        }
+    }
+    const ephemeralNode = findNodeChild(target, WA_NODE_TAGS.EPHEMERAL);
+    const ephemeral = ephemeralNode?.attrs.expiration
+        ? Number(ephemeralNode.attrs.expiration)
+        : undefined;
+    return {
+        jid: attrs.id ?? attrs.jid ?? '',
+        subject: attrs.subject ?? '',
+        subjectOwner: attrs.s_o ?? attrs.subject_owner,
+        subjectTime: attrs.s_t ? Number(attrs.s_t) : undefined,
+        owner: attrs.creator ?? attrs.owner,
+        creation: attrs.creation ? Number(attrs.creation) : undefined,
+        desc,
+        descId: descNode?.attrs.id,
+        descOwner: descNode?.attrs.participant,
+        restrict: hasNodeChild(target, WA_NODE_TAGS.LOCKED),
+        announce: hasNodeChild(target, WA_NODE_TAGS.ANNOUNCEMENT),
+        ephemeral,
+        size: attrs.size ? Number(attrs.size) : undefined,
+        participants: parseGroupParticipants(target)
+    };
+}
+const SETTING_TAGS = {
+    announcement: { on: 'announcement', off: 'not_announcement' },
+    restrict: { on: 'locked', off: 'unlocked' },
+    ephemeral: { on: 'ephemeral', off: 'not_ephemeral' },
+    membership_approval_mode: { on: 'membership_approval_mode', off: 'membership_approval_mode' }
+};
+export function createGroupCoordinator(options) {
+    const { queryWithContext } = options;
+    const changeParticipants = async (action, groupJid, participants) => {
+        const context = `group.${action}Participants`;
+        const node = buildGroupParticipantChangeIq({
+            groupJid,
+            action,
+            participants
+        });
+        const result = await queryWithContext(context, node);
+        assertIqResult(result, context);
+        return result;
+    };
+    return {
+        queryGroupMetadata: async (groupJid) => {
+            const node = buildIqNode('get', groupJid, WA_XMLNS.GROUPS, [
+                {
+                    tag: WA_NODE_TAGS.QUERY,
+                    attrs: {}
+                }
+            ]);
+            const result = await queryWithContext('group.metadata', node);
+            assertIqResult(result, 'group.metadata');
+            return parseGroupMetadata(result);
+        },
+        queryAllGroups: async () => {
+            const node = buildIqNode('get', WA_DEFAULTS.GROUP_SERVER, WA_XMLNS.GROUPS, [
+                {
+                    tag: WA_NODE_TAGS.PARTICIPATING,
+                    attrs: {},
+                    content: [
+                        { tag: WA_NODE_TAGS.PARTICIPANTS, attrs: {} },
+                        { tag: WA_NODE_TAGS.DESCRIPTION, attrs: {} }
+                    ]
+                }
+            ]);
+            const result = await queryWithContext('group.list', node);
+            assertIqResult(result, 'group.list');
+            const groupNodes = getNodeChildren(result).flatMap((child) => getNodeChildrenByTag(child, WA_NODE_TAGS.GROUP));
+            return groupNodes.map(parseGroupMetadata);
+        },
+        queryGroupInviteInfo: async (code) => {
+            const node = buildIqNode('get', WA_DEFAULTS.GROUP_SERVER, WA_XMLNS.GROUPS, [
+                { tag: WA_NODE_TAGS.INVITE, attrs: { code } }
+            ]);
+            const result = await queryWithContext('group.invite.info', node);
+            assertIqResult(result, 'group.invite.info');
+            return result;
+        },
+        createGroup: async (subject, participants, opts) => {
+            const node = buildCreateGroupIq({
+                subject,
+                participants,
+                description: opts?.description
+            });
+            const result = await queryWithContext('group.create', node);
+            assertIqResult(result, 'group.create');
+            return result;
+        },
+        setSubject: async (groupJid, subject) => {
+            const node = buildIqNode('set', groupJid, WA_XMLNS.GROUPS, [
+                { tag: WA_NODE_TAGS.SUBJECT, attrs: {}, content: subject }
+            ]);
+            const result = await queryWithContext('group.setSubject', node);
+            assertIqResult(result, 'group.setSubject');
+        },
+        setDescription: async (groupJid, description, prevDescId) => {
+            const descId = `${Date.now()}`;
+            const attrs = { id: descId };
+            if (prevDescId)
+                attrs.prev = prevDescId;
+            let content;
+            if (description === null) {
+                attrs.delete = 'true';
+            }
+            else {
+                content = [{ tag: WA_NODE_TAGS.BODY, attrs: {}, content: description }];
+            }
+            const node = buildIqNode('set', groupJid, WA_XMLNS.GROUPS, [
+                { tag: WA_NODE_TAGS.DESCRIPTION, attrs, content }
+            ]);
+            const result = await queryWithContext('group.setDescription', node);
+            assertIqResult(result, 'group.setDescription');
+        },
+        setSetting: async (groupJid, setting, enabled) => {
+            const tags = SETTING_TAGS[setting];
+            const tag = enabled ? tags.on : tags.off;
+            let content;
+            if (setting === 'membership_approval_mode') {
+                content = [
+                    {
+                        tag: WA_NODE_TAGS.GROUP_JOIN,
+                        attrs: { state: enabled ? 'on' : 'off' }
+                    }
+                ];
+            }
+            const node = buildIqNode('set', groupJid, WA_XMLNS.GROUPS, [
+                { tag, attrs: {}, ...(content ? { content } : {}) }
+            ]);
+            const result = await queryWithContext('group.setSetting', node);
+            assertIqResult(result, 'group.setSetting');
+        },
+        addParticipants: async (groupJid, participants) => changeParticipants('add', groupJid, participants),
+        removeParticipants: async (groupJid, participants) => changeParticipants('remove', groupJid, participants),
+        promoteParticipants: async (groupJid, participants) => changeParticipants('promote', groupJid, participants),
+        demoteParticipants: async (groupJid, participants) => changeParticipants('demote', groupJid, participants),
+        leaveGroup: async (groupJids) => {
+            const node = buildLeaveGroupIq(groupJids);
+            const result = await queryWithContext('group.leave', node);
+            assertIqResult(result, 'group.leave');
+            return result;
+        },
+        revokeInvite: async (groupJid) => {
+            const node = buildIqNode('set', groupJid, WA_XMLNS.GROUPS, [
+                { tag: WA_NODE_TAGS.INVITE, attrs: {} }
+            ]);
+            const result = await queryWithContext('group.revokeInvite', node);
+            assertIqResult(result, 'group.revokeInvite');
+            return result;
+        },
+        joinGroupViaInvite: async (code) => {
+            const node = buildIqNode('set', WA_DEFAULTS.GROUP_SERVER, WA_XMLNS.GROUPS, [
+                { tag: WA_NODE_TAGS.INVITE, attrs: { code } }
+            ]);
+            const result = await queryWithContext('group.joinViaInvite', node);
+            assertIqResult(result, 'group.joinViaInvite');
+            return result;
+        }
+    };
+}