@towns-protocol/bot 0.0.412 → 0.0.414

package/dist/bot.test.js

@@ -13,6 +13,7 @@ import { Hono } from 'hono';
 import { randomUUID } from 'crypto';
 import { getBalance, readContract, waitForTransactionReceipt } from 'viem/actions';
 import townsAppAbi from '@towns-protocol/generated/dev/abis/ITownsApp.abi';
+import channelsFacetAbi from '@towns-protocol/generated/dev/abis/Channels.abi';
 import { parseEther } from 'viem';
 import { execute } from 'viem/experimental/erc7821';
 const log = dlog('test:bot');
@@ -22,6 +23,7 @@ const SLASH_COMMANDS = [
     { name: 'status', description: 'Check bot status' },
 ];
 describe('Bot', { sequential: true }, () => {
+    const subscriptions = [];
     const townsConfig = townsEnv().makeTownsConfig();
     const bob = new SyncAgentTest(undefined, townsConfig);
     const appRegistryDapp = new AppRegistryDapp(townsConfig.base.chainConfig, makeBaseProvider(townsConfig));
@@ -59,6 +61,10 @@ describe('Bot', { sequential: true }, () => {
             client.debugForceMakeMiniblock(channelId, { forceSnapshot: true }),
         ]));
     });
+    afterEach(() => {
+        subscriptions.forEach((unsub) => unsub());
+        subscriptions.splice(0, subscriptions.length);
+    });
     const setForwardSetting = async (forwardSetting) => {
         await appRegistryRpcClient.setAppSettings({
             appId: bin_fromHexString(botClientAddress),
@@ -117,6 +123,7 @@ describe('Bot', { sequential: true }, () => {
         const cryptoStore = RiverDbManager.getCryptoDb(appAddress);
         const botClient = new Client(signerContext, rpcClient, cryptoStore, new MockEntitlementsDelegate());
         await expect(botClient.initializeUser({ appAddress, skipSync: true })).resolves.toBeDefined();
+        await botClient.uploadDeviceKeys();
         await bobClient.riverConnection.call((client) => client.joinUser(spaceId, botClient.userId));
         await bobClient.riverConnection.call((client) => client.joinUser(channelId, botClient.userId));
         const addResult = await botClient.uploadDeviceKeys();
@@ -188,13 +195,34 @@ describe('Bot', { sequential: true }, () => {
         expect(joined.has(botClientAddress)).toBe(true);
         expect(joined.get(botClientAddress)?.appAddress).toBe(appAddress);
     });
+    it('should be entitled', async () => {
+        const spaceDapp = bobClient.riverConnection.spaceDapp;
+        const isInstalled = await spaceDapp.isAppInstalled(spaceId, bot.appAddress);
+        expect(isInstalled).toBe(true);
+        const isEntitledRead = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.Read);
+        const isEntitledWrite = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.Write);
+        const isEntitledReact = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.React);
+        const isEntitledModifyBanning = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.ModifyBanning);
+        const isEntitledModifySpaceSettings = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.ModifySpaceSettings);
+        const isEntitledRedact = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.Redact);
+        const isEntitledPinMessage = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.PinMessage);
+        const isEntitledAddRemove = await spaceDapp.isAppEntitled(spaceId, bot.botId, bot.appAddress, Permission.AddRemoveChannels);
+        expect(isEntitledRead).toBe(true);
+        expect(isEntitledWrite).toBe(true);
+        expect(isEntitledReact).toBe(true);
+        expect(isEntitledModifyBanning).toBe(true);
+        expect(isEntitledModifySpaceSettings).toBe(true);
+        expect(isEntitledRedact).toBe(true);
+        expect(isEntitledPinMessage).toBe(true);
+        expect(isEntitledAddRemove).toBe(true);
+    });
     it('should receive a message forwarded', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const timeBeforeSendMessage = Date.now();
         let receivedMessages = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const TEST_MESSAGE = 'Hello bot!';
         const { eventId } = await bobDefaultChannel.sendMessage(TEST_MESSAGE);
         await waitFor(() => receivedMessages.length > 0, { timeoutMS: 15_000 });
@@ -222,9 +250,9 @@ describe('Bot', { sequential: true }, () => {
     it('should not receive messages when forwarding is set to no messages', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_NO_MESSAGES);
         const receivedMessages = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const TEST_MESSAGE = 'This message should not be forwarded';
         await bobDefaultChannel.sendMessage(TEST_MESSAGE);
         await new Promise((resolve) => setTimeout(resolve, 2500));
@@ -233,9 +261,9 @@ describe('Bot', { sequential: true }, () => {
     it('should receive channel join event when alice joins the channel if bot is listening to channel join events', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedChannelJoinEvents = [];
-        bot.onChannelJoin((_h, e) => {
+        subscriptions.push(bot.onChannelJoin((_h, e) => {
             receivedChannelJoinEvents.push(e);
-        });
+        }));
         await aliceClient.spaces.joinSpace(spaceId, alice.signer);
         await waitFor(() => receivedChannelJoinEvents.length > 0);
         expect(receivedChannelJoinEvents.find((x) => x.userId === alice.userId)).toBeDefined();
@@ -249,9 +277,9 @@ describe('Bot', { sequential: true }, () => {
     it('should receive slash command messages', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onSlashCommand('help', (_h, e) => {
+        subscriptions.push(bot.onSlashCommand('help', (_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const { eventId } = await bobDefaultChannel.sendMessage('/help', {
             appClientAddress: bot.botId,
         });
@@ -263,9 +291,9 @@ describe('Bot', { sequential: true }, () => {
     it('should receive slash command in a thread', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onSlashCommand('help', (_h, e) => {
+        subscriptions.push(bot.onSlashCommand('help', (_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const { eventId: threadId } = await bobDefaultChannel.sendMessage('starting a thread');
         const { eventId } = await bobDefaultChannel.sendMessage('/help', {
             appClientAddress: bot.botId,
@@ -280,9 +308,9 @@ describe('Bot', { sequential: true }, () => {
     it('should receive slash command as a reply', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onSlashCommand('help', (_h, e) => {
+        subscriptions.push(bot.onSlashCommand('help', (_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const { eventId: replyId } = await bobDefaultChannel.sendMessage('yo');
         const { eventId } = await bobDefaultChannel.sendMessage('/help', {
             appClientAddress: bot.botId,
@@ -297,9 +325,9 @@ describe('Bot', { sequential: true }, () => {
     it('should receive slash command with arguments', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onSlashCommand('status', (_h, e) => {
+        subscriptions.push(bot.onSlashCommand('status', (_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const { eventId } = await bobDefaultChannel.sendMessage('/status detailed info', {
             appClientAddress: bot.botId,
         });
@@ -311,9 +339,9 @@ describe('Bot', { sequential: true }, () => {
     it('onMessageEdit should be triggered when a message is edited', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedEditEvents = [];
-        bot.onMessageEdit((_h, e) => {
+        subscriptions.push(bot.onMessageEdit((_h, e) => {
             receivedEditEvents.push(e);
-        });
+        }));
         const originalMessage = 'Original message to delete';
         const editedMessage = 'Edited message content';
         const { eventId: originalMessageId } = await bobDefaultChannel.sendMessage(originalMessage);
@@ -326,11 +354,11 @@ describe('Bot', { sequential: true }, () => {
     it('onMessage should be triggered with threadId when a message is sent in a thread', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedThreadMessages = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             if (e.threadId) {
                 receivedThreadMessages.push(e);
             }
-        });
+        }));
         const initialMessage = 'Starting a thread';
         const threadReply = 'Replying in thread';
         const { eventId: initialMessageId } = await bobDefaultChannel.sendMessage(initialMessage);
@@ -347,11 +375,11 @@ describe('Bot', { sequential: true }, () => {
     it('onMessage should be triggered with isMentioned when a bot is mentioned', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMentionedEvents = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             if (e.isMentioned) {
                 receivedMentionedEvents.push(e);
             }
-        });
+        }));
         const TEST_MESSAGE = 'Hello @bot';
         const { eventId } = await bobDefaultChannel.sendMessage(TEST_MESSAGE, {
             mentions: [
@@ -372,9 +400,9 @@ describe('Bot', { sequential: true }, () => {
     it('isMentioned should be false when someone else is mentioned', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const TEST_MESSAGE = 'Hello @alice';
         const { eventId } = await bobDefaultChannel.sendMessage(TEST_MESSAGE, {
             mentions: [
@@ -393,9 +421,9 @@ describe('Bot', { sequential: true }, () => {
     it('onMessage should be triggered with both threadId and isMentioned when bot is mentioned in a thread', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMentionedInThreadEvents = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             receivedMentionedInThreadEvents.push(e);
-        });
+        }));
         const { eventId: initialMessageId } = await bobDefaultChannel.sendMessage('starting a thread');
         const { eventId: threadMentionEventId } = await bobDefaultChannel.sendMessage('yo @bot check this thread', {
             threadId: initialMessageId,
@@ -417,9 +445,9 @@ describe('Bot', { sequential: true }, () => {
     it('thread message without bot mention should have isMentioned false', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             receivedMessages.push(e);
-        });
+        }));
         const initialMessage = 'Starting another thread';
         const threadMessageWithoutMention = 'Thread message without mention';
         const { eventId: initialMessageId } = await bobDefaultChannel.sendMessage(initialMessage);
@@ -435,9 +463,9 @@ describe('Bot', { sequential: true }, () => {
     it('onReaction should be triggered when a reaction is added', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedReactionEvents = [];
-        bot.onReaction((_h, e) => {
+        subscriptions.push(bot.onReaction((_h, e) => {
             receivedReactionEvents.push(e);
-        });
+        }));
         const { eventId: messageId } = await bobClient.spaces
             .getSpace(spaceId)
             .getChannel(channelId)
@@ -452,9 +480,9 @@ describe('Bot', { sequential: true }, () => {
     it('onRedaction should be triggered when a message is redacted', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedRedactionEvents = [];
-        bot.onRedaction((_h, e) => {
+        subscriptions.push(bot.onRedaction((_h, e) => {
             receivedRedactionEvents.push(e);
-        });
+        }));
         const { eventId: messageId } = await bobDefaultChannel.sendMessage('Hello');
         const { eventId: redactionId } = await bobDefaultChannel.redact(messageId);
         await waitFor(() => receivedRedactionEvents.length > 0);
@@ -528,9 +556,9 @@ describe('Bot', { sequential: true }, () => {
     it('bot can redact other people messages', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const messages = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             messages.push(e);
-        });
+        }));
         const { eventId: bobMessageId } = await bobDefaultChannel.sendMessage('Hello');
         await waitFor(() => expect(bobDefaultChannel.timeline.events.value.find((x) => x.eventId === bobMessageId)
             ?.content?.kind).toBe(RiverTimelineEvent.ChannelMessage));
@@ -544,9 +572,9 @@ describe('Bot', { sequential: true }, () => {
     it.skip('onMessage should be triggered with replyId when a message is replied to', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS);
         const receivedReplyEvents = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             receivedReplyEvents.push(e);
-        });
+        }));
         const { eventId: messageId } = await bot.sendMessage(channelId, 'hii');
         await waitFor(() => expect(bobDefaultChannel.timeline.events.value.find((x) => x.eventId === messageId)).toBeDefined());
         const { eventId: replyEventId } = await bobDefaultChannel.sendMessage('hi back', {
@@ -560,9 +588,9 @@ describe('Bot', { sequential: true }, () => {
     it('onTip should be triggered when a tip is received', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedTipEvents = [];
-        bot.onTip((_h, e) => {
+        subscriptions.push(bot.onTip((_h, e) => {
             receivedTipEvents.push(e);
-        });
+        }));
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const { eventId: messageId } = await bot.sendMessage(channelId, 'hii');
         const balanceBefore = (await ethersProvider.getBalance(appAddress)).toBigInt();
@@ -602,7 +630,7 @@ describe('Bot', { sequential: true }, () => {
     it('bot can use sendTip() to send tips using app balance', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onMessage(async (handler, event) => {
+        subscriptions.push(bot.onMessage(async (handler, event) => {
             const result = await handler.sendTip({
                 userId: bob.userId,
                 amount: ethers.utils.parseUnits('0.005').toBigInt(),
@@ -612,7 +640,7 @@ describe('Bot', { sequential: true }, () => {
             expect(result.txHash).toBeDefined();
             expect(result.eventId).toBeDefined();
             receivedMessages.push(event);
-        });
+        }));
         const bobBalanceBefore = (await ethersProvider.getBalance(bob.userId)).toBigInt();
         // Bob sends a message asking for a tip
         const { eventId: bobMessageId } = await bobDefaultChannel.sendMessage('Tip me please!');
@@ -624,9 +652,9 @@ describe('Bot', { sequential: true }, () => {
     it('onEventRevoke (FORWARD_SETTING_ALL_MESSAGES) should be triggered when a message is revoked', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedEventRevokeEvents = [];
-        bot.onEventRevoke((_h, e) => {
+        subscriptions.push(bot.onEventRevoke((_h, e) => {
             receivedEventRevokeEvents.push(e);
-        });
+        }));
         const { eventId: messageId } = await bot.sendMessage(channelId, 'hii');
         await bobDefaultChannel.adminRedact(messageId);
         await waitFor(() => receivedEventRevokeEvents.length > 0);
@@ -635,9 +663,9 @@ describe('Bot', { sequential: true }, () => {
     it.fails('onEventRevoke (FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS) should be triggered when a message that mentions the bot is revoked', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS);
         const receivedEventRevokeEvents = [];
-        bot.onEventRevoke((_h, e) => {
+        subscriptions.push(bot.onEventRevoke((_h, e) => {
             receivedEventRevokeEvents.push(e);
-        });
+        }));
         const { eventId: messageId } = await bobDefaultChannel.sendMessage('hii @bot', {
             mentions: [
                 {
@@ -656,9 +684,9 @@ describe('Bot', { sequential: true }, () => {
         await appRegistryDapp.uninstallApp(bob.signer, appAddress, SpaceAddressFromSpaceId(spaceId));
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMentionedEvents = [];
-        bot.onMessage((_h, e) => {
+        subscriptions.push(bot.onMessage((_h, e) => {
             receivedMentionedEvents.push(e);
-        });
+        }));
         const TEST_MESSAGE = 'wont be received';
         const { eventId } = await bobDefaultChannel.sendMessage(TEST_MESSAGE);
         await expect(waitFor(() => receivedMentionedEvents.length > 0)).rejects.toThrow();
@@ -865,9 +893,9 @@ describe('Bot', { sequential: true }, () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const messageSchema = z.object({ text: z.string(), count: z.number() });
         const receivedGmEvents = [];
-        bot.onGmMessage('test.typed.v1', messageSchema, (_h, e) => {
+        subscriptions.push(bot.onGmMessage('test.typed.v1', messageSchema, (_h, e) => {
             receivedGmEvents.push({ typeUrl: e.typeUrl, data: e.data });
-        });
+        }));
         const testData = { text: 'Hello', count: 42 };
         // Bob sends the message so bot receives it (bot filters its own messages)
         const jsonString = superjsonStringify(testData);
@@ -910,12 +938,12 @@ describe('Bot', { sequential: true }, () => {
         const schema2 = z.object({ type: z.literal('type2'), text: z.string() });
         const receivedType1 = [];
         const receivedType2 = [];
-        bot.onGmMessage('test.multi.type1', schema1, (_h, e) => {
+        subscriptions.push(bot.onGmMessage('test.multi.type1', schema1, (_h, e) => {
             receivedType1.push(e.data);
-        });
-        bot.onGmMessage('test.multi.type2', schema2, (_h, e) => {
+        }));
+        subscriptions.push(bot.onGmMessage('test.multi.type2', schema2, (_h, e) => {
             receivedType2.push(e.data);
-        });
+        }));
         const data1 = { type: 'type1', value: 123 };
         const data2 = { type: 'type2', text: 'hello' };
         await bobClient.riverConnection.call((client) => client.sendChannelMessage_GM(channelId, {
@@ -937,9 +965,9 @@ describe('Bot', { sequential: true }, () => {
     it('should handle raw GM messages', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
         const receivedMessages = [];
-        bot.onRawGmMessage((_h, e) => {
+        subscriptions.push(bot.onRawGmMessage((_h, e) => {
             receivedMessages.push({ typeUrl: e.typeUrl, message: e.message });
-        });
+        }));
         const message = new TextEncoder().encode('Hello, world!');
         await bobClient.riverConnection.call((client) => client.sendChannelMessage_GM(channelId, {
             content: {
@@ -984,9 +1012,9 @@ describe('Bot', { sequential: true }, () => {
     it('should log error and continue processing if throws an error when handling an event', async () => {
         const consoleErrorSpy = vi.spyOn(console, 'error');
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
-        expect(() => bot.onMessage(() => {
+        subscriptions.push(bot.onMessage(() => {
             throw new Error('test error');
-        })).not.toThrow();
+        }));
         await bobDefaultChannel.sendMessage('lol');
         await waitFor(() => consoleErrorSpy.mock.calls.length > 0);
         expect(consoleErrorSpy.mock.calls[0][0]).toContain('[@towns-protocol/bot] Error while handling event');
@@ -1024,6 +1052,73 @@ describe('Bot', { sequential: true }, () => {
                 ?.kind).toBe(RiverTimelineEvent.ChannelMessage);
         }, { timeoutMS: 20000 });
     });
+    it('bot can create channel, channel has the role, bob joins and sends message, bot receives message', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const streamEvents = [];
+        const receivedMessages = [];
+        subscriptions.push(bot.onStreamEvent((_h, e) => {
+            log('stream event', e);
+            streamEvents.push(e);
+        }));
+        subscriptions.push(bot.onMessage((_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const spaceDapp = bobClient.riverConnection.spaceDapp;
+        const testNft1Address = await TestERC721.getContractAddress('TestNFT1');
+        const ruleData = getNftRuleData(testNft1Address);
+        const permissions = [Permission.Read, Permission.Write];
+        const roleName = `TestRole for bot channel bot wallet`;
+        // Bob creates a role with Read permission
+        const txn = await spaceDapp.createRole(spaceId, roleName, permissions, [], ruleData, bob.signer);
+        const { roleId, error: roleError } = await waitForRoleCreated(spaceDapp, spaceId, txn);
+        expect(roleError).toBeUndefined();
+        check(isDefined(roleId), 'roleId is defined');
+        log('bob created role', roleId);
+        // Bot creates a new channel
+        const newChannelId = await bot.createChannel(spaceId, {
+            name: `test-channel-with-role-bot`,
+            description: `Channel with role created by bot with bot wallet`,
+        });
+        log(`bot created channel`, newChannelId);
+        // Query the roles assigned to the channel
+        const channelRoles = await readContract(bot.viem, {
+            address: SpaceAddressFromSpaceId(spaceId),
+            abi: channelsFacetAbi,
+            functionName: 'getRolesByChannel',
+            args: [
+                newChannelId.startsWith('0x')
+                    ? newChannelId
+                    : `0x${newChannelId}`,
+            ],
+        });
+        log('channel roles', channelRoles);
+        // Verify the created role is included in the channel's roles
+        expect(channelRoles).toContain(BigInt(roleId));
+        // Bob joins the new channel
+        await bobClient.riverConnection.call((client) => client.joinStream(newChannelId));
+        // Bob gets the channel
+        const bobNewChannel = bobClient.spaces.getSpace(spaceId).getChannel(newChannelId);
+        await waitFor(() => bobNewChannel.value.status !== 'loading', { timeoutMS: 10000 });
+        // Bob sends a message in the new channel
+        const testMessage = `Hello bot in new channel`;
+        log('bob sending message in new channel', {
+            testMessage,
+            botId: bot.botId,
+            appAddress: bot.appAddress,
+            bobUserId: bob.userId,
+        });
+        const { eventId } = await bobNewChannel.sendMessage(testMessage);
+        log('bob sent message in new channel', eventId);
+        await waitFor(() => streamEvents.length > 0, { timeoutMS: 15000 });
+        await waitFor(() => expect(streamEvents.find((x) => x.eventId === eventId)).toBeDefined());
+        // Wait for bot to receive the message
+        await waitFor(() => receivedMessages.length > 0, { timeoutMS: 15000 });
+        const receivedEvent = receivedMessages.find((x) => x.eventId === eventId);
+        expect(receivedEvent).toBeDefined();
+        expect(receivedEvent?.message).toBe(testMessage);
+        expect(receivedEvent?.channelId).toBe(newChannelId);
+        expect(receivedEvent?.userId).toBe(bobClient.userId);
+    });
     it('bot should be able to send encrypted interaction request and user should send encrypted response', async () => {
         await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS);
         const requestId = randomUUID();
@@ -1074,9 +1169,9 @@ describe('Bot', { sequential: true }, () => {
             },
         };
         const receivedInteractionResponses = [];
-        bot.onInteractionResponse((_h, e) => {
+        subscriptions.push(bot.onInteractionResponse((_h, e) => {
             receivedInteractionResponses.push(e.response);
-        });
+        }));
         await bobClient.riverConnection.call(async (client) => {
             // from the client, to the channel, encrypted so that only the bot can read it
             return await client.sendInteractionResponse(channelId, recipient, interactionResponsePayload, encryptionDevice);
@@ -1143,9 +1238,9 @@ describe('Bot', { sequential: true }, () => {
             },
         };
         const receivedInteractionResponses = [];
-        bot.onInteractionResponse((_h, e) => {
+        subscriptions.push(bot.onInteractionResponse((_h, e) => {
             receivedInteractionResponses.push(e.response);
-        });
+        }));
         await bobClient.riverConnection.call(async (client) => {
             return await client.sendInteractionResponse(channelId, recipient, interactionResponsePayload, bot.getUserDevice());
         });