@towns-protocol/bot 0.0.260

package/dist/bot.js

@@ -0,0 +1,705 @@
+// Crypto Store uses IndexedDB, so we need to import fake-indexeddb/auto
+import 'fake-indexeddb/auto';
+import { create, fromBinary, fromJsonString, toBinary } from '@bufbuild/protobuf';
+import { getRefEventIdFromChannelMessage, isChannelStreamId, isDMChannelStreamId, isGDMChannelStreamId, makeEvent, make_ChannelPayload_Message, make_DMChannelPayload_Message, make_GDMChannelPayload_Message, streamIdAsBytes, createTownsClient, streamIdAsString, make_MemberPayload_KeySolicitation, make_UserMetadataPayload_EncryptionDevice, logNever, userIdFromAddress, makeUserMetadataStreamId, unsafe_makeTags, getStreamMetadataUrl, makeBaseChainConfig, usernameChecksum, make_MemberPayload_Username, make_MemberPayload_DisplayName, make_UserMetadataPayload_ProfileImage, spaceIdFromChannelId, } from '@towns-protocol/sdk';
+import { Hono } from 'hono';
+import EventEmitter from 'node:events';
+import { ChannelMessageSchema, AppServiceRequestSchema, AppServiceResponseSchema, SessionKeysSchema, AppPrivateDataSchema, MembershipOp, ChunkedMediaSchema, EncryptedDataSchema, } from '@towns-protocol/proto';
+import { bin_fromBase64, bin_fromHexString, bin_toHexString, bin_toString, check, } from '@towns-protocol/dlog';
+import { AES_GCM_DERIVED_ALGORITHM, GroupEncryptionAlgorithmId, parseGroupEncryptionAlgorithmId, } from '@towns-protocol/encryption';
+import { createClient as createViemClient, http, } from 'viem';
+import { readContract, writeContract, } from 'viem/actions';
+import { base, baseSepolia } from 'viem/chains';
+// Import the jsonwebtoken library and necessary dlog utilities
+import { default as jwt } from 'jsonwebtoken';
+import { deriveKeyAndIV, encryptAESGCM, uint8ArrayToBase64 } from '@towns-protocol/sdk-crypto';
+export class Bot extends EventEmitter {
+    server;
+    client;
+    botId;
+    viemClient;
+    jwtSecret;
+    currentMessageTags;
+    constructor(clientV2, viemClient, jwtSecretBase64) {
+        super();
+        this.client = clientV2;
+        this.botId = clientV2.userId;
+        this.viemClient = viemClient;
+        this.jwtSecret = bin_fromBase64(jwtSecretBase64);
+        this.currentMessageTags = undefined;
+        this.server = new Hono();
+        this.server.post('webhook', (c) => this.webhookResponseHandler(c));
+    }
+    async start() {
+        await this.client.uploadDeviceKeys();
+        return { fetch: this.server.fetch };
+    }
+    async webhookResponseHandler(c) {
+        const authHeader = c.req.header('Authorization');
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            return c.text('Unauthorized: Missing or malformed token', 401);
+        }
+        else {
+            const tokenString = authHeader.substring(7);
+            try {
+                // Convert botId (Ethereum address string, e.g., "0xABC") to raw bytes,
+                // then to a lowercase hex string for the audience check.
+                // This must match how the Go service creates the 'aud' claim.
+                const botAddressBytes = bin_fromHexString(this.botId);
+                // Assumes lowercase hex output without "0x"
+                const expectedAudience = bin_toHexString(botAddressBytes);
+                jwt.verify(tokenString, Buffer.from(this.jwtSecret), {
+                    algorithms: ['HS256'],
+                    audience: expectedAudience,
+                });
+            }
+            catch (err) {
+                let errorMessage = 'Unauthorized: Token verification failed';
+                if (err instanceof jwt.TokenExpiredError) {
+                    errorMessage = 'Unauthorized: Token expired';
+                }
+                else if (err instanceof jwt.JsonWebTokenError) {
+                    errorMessage = `Unauthorized: Invalid token (${err.message})`;
+                }
+                return c.text(errorMessage, 401);
+            }
+        }
+        const body = await c.req.arrayBuffer();
+        const encryptionDevice = this.client.crypto.getUserDevice();
+        const request = fromBinary(AppServiceRequestSchema, new Uint8Array(body));
+        const statusResponse = create(AppServiceResponseSchema, {
+            payload: {
+                case: 'status',
+                value: {
+                    frameworkVersion: 1,
+                    deviceKey: encryptionDevice.deviceKey,
+                    fallbackKey: encryptionDevice.fallbackKey,
+                },
+            },
+        });
+        let response = statusResponse;
+        if (request.payload.case === 'initialize') {
+            response = create(AppServiceResponseSchema, {
+                payload: {
+                    case: 'initialize',
+                    value: {
+                        encryptionDevice,
+                    },
+                },
+            });
+        }
+        else if (request.payload.case === 'events') {
+            for (const event of request.payload.value.events) {
+                await this.handleEvent(event);
+            }
+            response = statusResponse;
+        }
+        else if (request.payload.case === 'status') {
+            response = statusResponse;
+        }
+        c.header('Content-Type', 'application/x-protobuf');
+        return c.body(toBinary(AppServiceResponseSchema, response), 200);
+    }
+    // TODO: onTip
+    async handleEvent(appEvent) {
+        if (!appEvent.payload.case || !appEvent.payload.value)
+            return;
+        const streamId = streamIdAsString(appEvent.payload.value.streamId);
+        if (appEvent.payload.case === 'messages') {
+            const groupEncryptionSessionsMessages = await this.client
+                .unpackEnvelopes(appEvent.payload.value.groupEncryptionSessionsMessages)
+                .then((x) => x.flatMap((e) => {
+                if (e.event.payload.case === 'userInboxPayload' &&
+                    e.event.payload.value.content.case === 'groupEncryptionSessions') {
+                    return e.event.payload.value.content.value;
+                }
+                return [];
+            }));
+            const events = await this.client.unpackEnvelopes(appEvent.payload.value.messages);
+            const zip = events.map((m, i) => [m, groupEncryptionSessionsMessages[i]]);
+            for (const [parsed, groupEncryptionSession] of zip) {
+                if (parsed.creatorUserId === this.client.userId) {
+                    continue;
+                }
+                if (!parsed.event.payload.case) {
+                    continue;
+                }
+                this.currentMessageTags = parsed.event.tags;
+                this.emit('streamEvent', this.client, {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    spaceId: spaceIdFromChannelId(streamId),
+                    channelId: streamId,
+                    eventId: parsed.hashStr,
+                    event: parsed,
+                });
+                switch (parsed.event.payload.case) {
+                    case 'channelPayload':
+                    case 'dmChannelPayload':
+                    case 'gdmChannelPayload': {
+                        if (!parsed.event.payload.value.content.case)
+                            return;
+                        if (parsed.event.payload.value.content.case === 'message') {
+                            const decryptedSessions = await this.client.decryptSessions(streamId, groupEncryptionSession);
+                            await this.client.crypto.importSessionKeys(streamId, decryptedSessions);
+                            const eventCleartext = await this.client.crypto.decryptGroupEvent(streamId, parsed.event.payload.value.content.value);
+                            let channelMessage;
+                            if (typeof eventCleartext === 'string') {
+                                channelMessage = fromJsonString(ChannelMessageSchema, eventCleartext);
+                            }
+                            else {
+                                channelMessage = fromBinary(ChannelMessageSchema, eventCleartext);
+                            }
+                            await this.handleChannelMessage(streamId, parsed, channelMessage);
+                        }
+                        else if (parsed.event.payload.value.content.case === 'redaction') {
+                            this.emit('eventRevoke', this.client, {
+                                userId: userIdFromAddress(parsed.event.creatorAddress),
+                                spaceId: spaceIdFromChannelId(streamId),
+                                channelId: streamId,
+                                refEventId: bin_toHexString(parsed.event.payload.value.content.value.eventId),
+                                eventId: parsed.hashStr,
+                            });
+                        }
+                        else if (parsed.event.payload.value.content.case === 'channelProperties') {
+                            // TODO: currently, no support for channel properties (update name, topic)
+                        }
+                        else if (parsed.event.payload.value.content.case === 'inception') {
+                            // TODO: is there any use case for this?
+                        }
+                        else {
+                            logNever(parsed.event.payload.value.content);
+                        }
+                        break;
+                    }
+                    case 'memberPayload': {
+                        if (parsed.event.payload.value.content.case === 'membership') {
+                            const membership = parsed.event.payload.value.content.value;
+                            const isChannel = isChannelStreamId(streamId);
+                            // TODO: do we want Bot to listen to onSpaceJoin/onSpaceLeave?
+                            if (!isChannel)
+                                continue;
+                            if (membership.op === MembershipOp.SO_JOIN) {
+                                this.emit('channelJoin', this.client, {
+                                    userId: userIdFromAddress(membership.userAddress),
+                                    spaceId: spaceIdFromChannelId(streamId),
+                                    channelId: streamId,
+                                    eventId: parsed.hashStr,
+                                });
+                            }
+                            if (membership.op === MembershipOp.SO_LEAVE) {
+                                this.emit('channelLeave', this.client, {
+                                    userId: userIdFromAddress(membership.userAddress),
+                                    spaceId: spaceIdFromChannelId(streamId),
+                                    channelId: streamId,
+                                    eventId: parsed.hashStr,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else if (appEvent.payload.case === 'solicitation') {
+            const missingSessionIds = appEvent.payload.value.sessionIds.filter((sessionId) => sessionId !== '');
+            await this.client.sendKeySolicitation(streamId, missingSessionIds);
+        }
+        else {
+            logNever(appEvent.payload);
+        }
+    }
+    async handleChannelMessage(streamId, parsed, { payload }) {
+        if (!payload.case) {
+            return;
+        }
+        switch (payload.case) {
+            case 'post': {
+                if (payload.value.content.case === 'text') {
+                    const hasBotMention = payload.value.content.value.mentions.some((m) => m.userId === this.botId);
+                    const userId = userIdFromAddress(parsed.event.creatorAddress);
+                    const replyId = payload.value.replyId;
+                    const threadId = payload.value.threadId;
+                    const forwardPayload = {
+                        userId,
+                        eventId: parsed.hashStr,
+                        spaceId: spaceIdFromChannelId(streamId),
+                        channelId: streamId,
+                        message: payload.value.content.value.body,
+                        isDm: isDMChannelStreamId(streamId),
+                        isGdm: isGDMChannelStreamId(streamId),
+                    };
+                    if (replyId) {
+                        this.emit('reply', this.client, forwardPayload);
+                    }
+                    else if (threadId) {
+                        this.emit('threadMessage', this.client, {
+                            ...forwardPayload,
+                            threadId,
+                        });
+                    }
+                    else if (hasBotMention) {
+                        this.emit('mentioned', this.client, forwardPayload);
+                    }
+                    else {
+                        this.emit('message', this.client, forwardPayload);
+                    }
+                }
+                break;
+            }
+            case 'reaction': {
+                this.emit('reaction', this.client, {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    eventId: parsed.hashStr,
+                    spaceId: spaceIdFromChannelId(streamId),
+                    channelId: streamId,
+                    reaction: payload.value.reaction,
+                    messageId: payload.value.refEventId,
+                });
+                break;
+            }
+            case 'edit': {
+                // TODO: framework doesnt handle non-text edits
+                if (payload.value.post?.content.case !== 'text')
+                    break;
+                this.emit('messageEdit', this.client, {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    eventId: parsed.hashStr,
+                    spaceId: spaceIdFromChannelId(streamId),
+                    channelId: streamId,
+                    refEventId: payload.value.refEventId,
+                    message: payload.value.post?.content.value.body,
+                });
+                break;
+            }
+            case 'redaction': {
+                this.emit('redaction', this.client, {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    eventId: parsed.hashStr,
+                    spaceId: spaceIdFromChannelId(streamId),
+                    channelId: streamId,
+                    refEventId: payload.value.refEventId,
+                });
+                break;
+            }
+            default:
+                logNever(payload);
+        }
+    }
+    /**
+     * Send a message to a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param message - The cleartext of the message
+     */
+    async sendMessage(streamId, message, opts) {
+        const result = await this.client.sendMessage(streamId, message, opts, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Send a reaction to a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param refEventId - The eventId of the event to react to
+     * @param reaction - The reaction to send
+     */
+    async sendReaction(streamId, refEventId, reaction) {
+        const result = await this.client.sendReaction(streamId, refEventId, reaction, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Remove an specific event from a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param refEventId - The eventId of the event to remove
+     */
+    async removeEvent(streamId, refEventId) {
+        const result = await this.client.removeEvent(streamId, refEventId, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Edit an specific message from a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param messageId - The eventId of the message to edit
+     * @param message - The new message text
+     */
+    async editMessage(streamId, messageId, message) {
+        const result = await this.client.editMessage(streamId, messageId, message, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    writeContract(tx) {
+        return writeContract(this.viemClient, tx);
+    }
+    readContract(parameters) {
+        return readContract(this.viemClient, parameters);
+    }
+    /**
+     * Triggered when someone sends a message.
+     * This is triggered for all messages, including direct messages and group messages.
+     */
+    onMessage(fn) {
+        this.on('message', fn);
+    }
+    onRedaction(fn) {
+        this.on('redaction', fn);
+    }
+    /**
+     * Triggered when a message gets edited
+     */
+    onMessageEdit(fn) {
+        this.on('messageEdit', fn);
+    }
+    /**
+     * Triggered when someone mentions the bot in a message
+     */
+    onMentioned(fn) {
+        this.on('mentioned', fn);
+    }
+    /**
+     * Triggered when someone replies to a message
+     */
+    onReply(fn) {
+        this.on('reply', fn);
+    }
+    /**
+     * Triggered when someone reacts to a message
+     */
+    onReaction(fn) {
+        this.on('reaction', fn);
+    }
+    /**
+     * Triggered when a message is revoked by a moderator
+     */
+    onEventRevoke(fn) {
+        this.on('eventRevoke', fn);
+    }
+    /**
+     * Triggered when someone tips the bot
+     * TODO: impl
+     */
+    onTip(fn) {
+        this.on('tip', fn);
+    }
+    /**
+     * Triggered when someone joins a channel
+     */
+    onChannelJoin(fn) {
+        this.on('channelJoin', fn);
+    }
+    /**
+     * Triggered when someone leaves a channel
+     */
+    onChannelLeave(fn) {
+        this.on('channelLeave', fn);
+    }
+    onStreamEvent(fn) {
+        this.on('streamEvent', fn);
+    }
+    onThreadMessage(fn) {
+        this.on('threadMessage', fn);
+    }
+}
+export const makeTownsBot = async (appPrivateDataBase64, jwtSecretBase64, env, baseRpcUrl) => {
+    const { privateKey, encryptionDevice } = fromBinary(AppPrivateDataSchema, bin_fromBase64(appPrivateDataBase64));
+    const baseConfig = makeBaseChainConfig(env);
+    const viemClient = createViemClient({
+        transport: baseRpcUrl
+            ? http(baseRpcUrl, { batch: true })
+            : http(baseConfig.rpcUrl, { batch: true }),
+        // TODO: would be nice if makeBaseChainConfig returned a viem chain
+        chain: baseConfig.chainConfig.chainId === base.id ? base : baseSepolia,
+    });
+    const client = await createTownsClient({
+        privateKey,
+        env,
+        encryptionDevice: {
+            fromExportedDevice: encryptionDevice,
+        },
+    }).then((x) => x.extend((townsClient) => buildBotActions(townsClient, viemClient)));
+    return new Bot(client, viemClient, jwtSecretBase64);
+};
+const buildBotActions = (client, viemClient) => {
+    const sendMessageEvent = async ({ streamId, payload, tags, }) => {
+        const stream = await client.getStream(streamId);
+        const { hash: prevMiniblockHash, miniblockNum: prevMiniblockNum } = await client.rpc.getLastMiniblockHash({
+            streamId: streamIdAsBytes(streamId),
+        });
+        const eventTags = {
+            ...unsafe_makeTags(payload),
+            participatingUserAddresses: tags?.participatingUserAddresses || [],
+            threadId: tags?.threadId || undefined,
+        };
+        const encryptionAlgorithm = stream.snapshot.members?.encryptionAlgorithm?.algorithm;
+        const message = await client.crypto.encryptGroupEvent(streamId, toBinary(ChannelMessageSchema, payload), encryptionAlgorithm ||
+            client.defaultGroupEncryptionAlgorithm);
+        message.refEventId = getRefEventIdFromChannelMessage(payload);
+        let event;
+        if (isChannelStreamId(streamId)) {
+            event = await makeEvent(client.signer, make_ChannelPayload_Message(message), prevMiniblockHash, prevMiniblockNum, eventTags);
+        }
+        else if (isDMChannelStreamId(streamId)) {
+            event = await makeEvent(client.signer, make_DMChannelPayload_Message(message), prevMiniblockHash, prevMiniblockNum, eventTags);
+        }
+        else if (isGDMChannelStreamId(streamId)) {
+            event = await makeEvent(client.signer, make_GDMChannelPayload_Message(message), prevMiniblockHash, prevMiniblockNum, eventTags);
+        }
+        else {
+            throw new Error(`Invalid stream ID type: ${streamId}`);
+        }
+        const eventId = bin_toHexString(event.hash);
+        const { error } = await client.rpc.addEvent({
+            streamId: streamIdAsBytes(streamId),
+            event,
+        });
+        return {
+            error,
+            eventId,
+            prevMiniblockHash,
+        };
+    };
+    const sendKeySolicitation = async (streamId, sessionIds) => {
+        const encryptionDevice = client.crypto.getUserDevice();
+        const missingSessionIds = sessionIds.filter((sessionId) => sessionId !== '');
+        const { hash: prevMiniblockHash } = await client.rpc.getLastMiniblockHash({
+            streamId: streamIdAsBytes(streamId),
+        });
+        const event = await makeEvent(client.signer, make_MemberPayload_KeySolicitation({
+            deviceKey: encryptionDevice.deviceKey,
+            fallbackKey: encryptionDevice.fallbackKey,
+            isNewDevice: missingSessionIds.length === 0,
+            sessionIds: missingSessionIds,
+        }), prevMiniblockHash);
+        const eventId = bin_toHexString(event.hash);
+        const { error } = await client.rpc.addEvent({
+            streamId: streamIdAsBytes(streamId),
+            event,
+        });
+        return { eventId, error };
+    };
+    const uploadDeviceKeys = async () => {
+        const streamId = streamIdAsBytes(makeUserMetadataStreamId(client.userId));
+        const { hash: prevMiniblockHash } = await client.rpc.getLastMiniblockHash({
+            streamId,
+        });
+        const encryptionDevice = client.crypto.getUserDevice();
+        const event = await makeEvent(client.signer, make_UserMetadataPayload_EncryptionDevice({
+            ...encryptionDevice,
+        }), prevMiniblockHash);
+        const eventId = bin_toHexString(event.hash);
+        const { error } = await client.rpc.addEvent({ streamId, event });
+        return { eventId, error };
+    };
+    const sendMessage = async (streamId, message, opts, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: {
+                case: 'post',
+                value: {
+                    threadId: opts?.threadId,
+                    replyId: opts?.replyId,
+                    replyPreview: opts?.replyId ? '🙈' : undefined,
+                    threadPreview: opts?.threadId ? '🙉' : undefined,
+                    content: {
+                        case: 'text',
+                        value: {
+                            body: message,
+                            attachments: opts?.attachments || [],
+                            mentions: opts?.mentions || [],
+                        },
+                    },
+                },
+            },
+        });
+        return sendMessageEvent({ streamId, payload, tags });
+    };
+    const editMessage = async (streamId, messageId, message, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: {
+                case: 'edit',
+                value: {
+                    refEventId: messageId,
+                    post: {
+                        content: { case: 'text', value: { body: message } },
+                    },
+                },
+            },
+        });
+        return sendMessageEvent({ streamId, payload, tags });
+    };
+    const sendDm = (userId, message, opts) => sendMessage(userId, message, opts);
+    const sendReaction = async (streamId, messageId, reaction, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: { case: 'reaction', value: { refEventId: messageId, reaction } },
+        });
+        return sendMessageEvent({ streamId, payload, tags });
+    };
+    const removeEvent = async (streamId, messageId, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: { case: 'redaction', value: { refEventId: messageId } },
+        });
+        return sendMessageEvent({ streamId, payload, tags });
+    };
+    const setUsername = async (streamId, username) => {
+        const encryptedData = await client.crypto.encryptGroupEvent(streamId, new TextEncoder().encode(username), client.defaultGroupEncryptionAlgorithm);
+        encryptedData.checksum = usernameChecksum(username, streamId);
+        const { hash: prevMiniblockHash } = await client.rpc.getLastMiniblockHash({
+            streamId: streamIdAsBytes(streamId),
+        });
+        const event = await makeEvent(client.signer, make_MemberPayload_Username(encryptedData), prevMiniblockHash);
+        const eventId = bin_toHexString(event.hash);
+        const { error } = await client.rpc.addEvent({
+            streamId: streamIdAsBytes(streamId),
+            event,
+        });
+        return { eventId, error };
+    };
+    const setDisplayName = async (streamId, displayName) => {
+        const encryptedData = await client.crypto.encryptGroupEvent(streamId, new TextEncoder().encode(displayName), client.defaultGroupEncryptionAlgorithm);
+        const { hash: prevMiniblockHash } = await client.rpc.getLastMiniblockHash({
+            streamId: streamIdAsBytes(streamId),
+        });
+        const event = await makeEvent(client.signer, make_MemberPayload_DisplayName(encryptedData), prevMiniblockHash);
+        const eventId = bin_toHexString(event.hash);
+        const { error } = await client.rpc.addEvent({
+            streamId: streamIdAsBytes(streamId),
+            event,
+        });
+        return { eventId, error };
+    };
+    const setUserProfileImage = async (chunkedMediaInfo) => {
+        const streamId = makeUserMetadataStreamId(client.userId);
+        const { key, iv } = await deriveKeyAndIV(client.userId);
+        const { ciphertext } = await encryptAESGCM(toBinary(ChunkedMediaSchema, create(ChunkedMediaSchema, chunkedMediaInfo)), key, iv);
+        const encryptedData = create(EncryptedDataSchema, {
+            ciphertext: uint8ArrayToBase64(ciphertext),
+            algorithm: AES_GCM_DERIVED_ALGORITHM,
+        });
+        const { hash: prevMiniblockHash } = await client.rpc.getLastMiniblockHash({
+            streamId: streamIdAsBytes(streamId),
+        });
+        const event = await makeEvent(client.signer, make_UserMetadataPayload_ProfileImage(encryptedData), prevMiniblockHash);
+        const eventId = bin_toHexString(event.hash);
+        const { error } = await client.rpc.addEvent({
+            streamId: streamIdAsBytes(streamId),
+            event,
+        });
+        return { eventId, error };
+    };
+    const decryptSessions = async (streamId, sessions) => {
+        const { deviceKey } = client.crypto.getUserDevice();
+        const ciphertext = sessions.ciphertexts[deviceKey];
+        if (!ciphertext) {
+            throw new Error('No ciphertext found for device key');
+        }
+        const parsed = parseGroupEncryptionAlgorithmId(sessions.algorithm, GroupEncryptionAlgorithmId.GroupEncryption);
+        if (parsed.kind === 'unrecognized') {
+            throw new Error('Invalid algorithm');
+        }
+        const algorithm = parsed.value;
+        // decrypt the session keys
+        const cleartext = await client.crypto.decryptWithDeviceKey(ciphertext, sessions.senderKey);
+        const sessionKeys = fromJsonString(SessionKeysSchema, cleartext);
+        check(sessionKeys.keys.length === sessions.sessionIds.length, 'bad sessionKeys');
+        // make group sessions that can be used to decrypt events
+        return sessions.sessionIds.map((sessionId, i) => ({
+            streamId: streamId,
+            sessionId,
+            sessionKey: sessionKeys.keys[i],
+            algorithm,
+        }));
+    };
+    /**
+     * Fetches and attempts to decrypt member-specific data (username, display name, nft, ensAddress)
+     * for a given user within a specific stream (channel/space).
+     * It requires the data to be in the stream snapshot.
+     *
+     * NOTE: Decryption relies on the bot having the necessary group session keys for the
+     * specified stream. If somehow the keys are missing, decryption will fail, and null values will be returned for username/displayName.
+     *
+     * @deprecated Not planned for now
+     * @param streamId - The ID of the channel or space stream.
+     * @param userId -  The ID of the member whose data is being requested.
+     */
+    const getUserData = async (streamId, userId) => {
+        try {
+            const stream = await client.getStream(streamId);
+            const members = stream.snapshot.members?.joined;
+            if (!members) {
+                return null;
+            }
+            const member = members.find((m) => userIdFromAddress(m.userAddress) === userId);
+            if (!member) {
+                return null;
+            }
+            let displayName = null;
+            let username = null;
+            const [usernameDecrypted, displayNameDecrypted] = await Promise.all([
+                member.username?.data
+                    ? client.crypto.decryptGroupEvent(streamId, member.username.data)
+                    : null,
+                member.displayName?.data
+                    ? client.crypto.decryptGroupEvent(streamId, member.displayName.data)
+                    : null,
+            ]);
+            if (usernameDecrypted) {
+                username =
+                    typeof usernameDecrypted === 'string'
+                        ? usernameDecrypted
+                        : bin_toString(usernameDecrypted);
+            }
+            if (displayNameDecrypted) {
+                displayName =
+                    typeof displayNameDecrypted === 'string'
+                        ? displayNameDecrypted
+                        : bin_toString(displayNameDecrypted);
+            }
+            let ensAddress = undefined;
+            if (member.ensAddress) {
+                ensAddress = `0x${bin_toHexString(member.ensAddress)}`;
+            }
+            let nft = undefined;
+            if (member.nft) {
+                nft = {
+                    tokenId: bin_toString(member.nft.tokenId),
+                    contractAddress: `0x${bin_toHexString(member.nft.contractAddress)}`,
+                    chainId: member.nft.chainId,
+                };
+            }
+            const bio = await fetch(`${getStreamMetadataUrl(client.env)}/user/${userId}/bio`)
+                .then((res) => res.json())
+                .then((data) => data.bio)
+                .catch(() => null);
+            const profilePictureUrl = `${getStreamMetadataUrl(client.env)}/user/${userId}/image`;
+            return {
+                userId,
+                username,
+                displayName,
+                ensAddress,
+                nft,
+                bio,
+                profilePictureUrl,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        // Is it those enough?
+        // TODO: think about a web3 use case..
+        writeContract: (tx) => writeContract(viemClient, tx),
+        readContract: (parameters) => readContract(viemClient, parameters),
+        sendMessage,
+        editMessage,
+        sendDm,
+        sendReaction,
+        removeEvent,
+        sendKeySolicitation,
+        uploadDeviceKeys,
+        decryptSessions,
+        setUsername,
+        setDisplayName,
+        setUserProfileImage,
+        /** @deprecated Not planned for now */
+        getUserData,
+    };
+};
+//# sourceMappingURL=bot.js.map