@towns-labs/sdk 2.0.11 → 2.0.13

package/dist/tests/multi_ne/streamRpcClient.test.js

@@ -1,94 +1,61 @@
 /**
  * @group main
  */
-import { makeEvent, makeEvents, unpackStreamEnvelopes } from '../../sign';
-import { MembershipOp, SyncOp } from '@towns-labs/proto';
+import { makeEvent, makeEvents } from '../../sign';
+import { MembershipOp } from '@towns-labs/proto';
 import { bin_equal, dlog } from '@towns-labs/utils';
-import { makeEvent_test, makeRandomUserContext, makeUserContextFromWallet, makeTestRpcClient, makeUniqueSpaceStreamId, iterableWrapper, TEST_ENCRYPTED_MESSAGE_PROPS, waitForSyncStreams, } from '../testUtils';
-import { addressFromUserId, makeUniqueChannelStreamId, makeUserStreamId, streamIdAsString, streamIdToBytes, userIdFromAddress, } from '../../id';
-import { make_ChannelPayload_Inception, make_ChannelPayload_Message, make_MemberPayload_Membership2, make_SpacePayload_Inception, make_UserPayload_Inception, make_UserPayload_UserMembership, make_UserPayload_UserMembershipAction, } from '../../types';
+import { makeEvent_test, makeRandomUserContext, makeUserContextFromWallet, makeTestRpcClient, TEST_ENCRYPTED_MESSAGE_PROPS, } from '../testUtils';
+import { makeUniqueGDMChannelStreamId, makeUserStreamId, streamIdToBytes, userIdFromAddress, } from '../../id';
+import { make_GDMChannelPayload_Inception, make_GDMChannelPayload_Message, make_MemberPayload_Membership2, make_UserPayload_Inception, make_UserPayload_UserMembership, } from '../../types';
 import { bobTalksToHimself } from '../bob_testUtils';
 import { ethers } from 'ethers';
 import { makeSignerContext } from '../../signerContext';
 const log = dlog('csb:test:streamRpcClient');
 describe('streamRpcClient', () => {
     let bobsContext;
-    let alicesContext;
     beforeEach(async () => {
         bobsContext = await makeRandomUserContext();
-        alicesContext = await makeRandomUserContext();
     });
     test('makeStreamRpcClient', async () => {
         const client = await makeTestRpcClient();
-        log('makeStreamRpcClient', 'url', client.url);
         expect(client).toBeDefined();
         const result = await client.info({ debug: ['graffiti'] });
         expect(result).toBeDefined();
         expect(result.graffiti).toEqual('River Node welcomes you!');
     });
     test('ping', async () => {
-        // ping is a debug endpoint, so it's not available in production
         const client = await makeTestRpcClient();
-        log('ping', 'url', client.url);
-        expect(client).toBeDefined();
         const result = await client.info({ debug: ['ping'] });
         expect(result).toBeDefined();
         expect(result.graffiti).toEqual('pong');
     });
     test('error', async () => {
         const client = await makeTestRpcClient();
-        expect(client).toBeDefined();
-        let err = undefined;
-        try {
-            await client.info({ debug: ['error'] });
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(Error);
-            err = e;
-        }
-        log('error', err);
-        expect(err).toBeDefined();
-        log('error', err.toString());
-        expect(err.toString()).toContain('Error requested through Info request');
+        await expect(client.info({ debug: ['error'] })).rejects.toThrow('Error requested through Info request');
     });
     test('error_untyped', async () => {
         const client = await makeTestRpcClient();
-        expect(client).toBeDefined();
-        let err = undefined;
-        try {
-            await client.info({ debug: ['error_untyped'] });
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(Error);
-            err = e;
-        }
-        log('error_untyped', err);
-        expect(err).toBeDefined();
-        log('error_untyped', err.toString());
-        expect(err.toString()).toContain('[unknown] error requested through Info request');
+        await expect(client.info({ debug: ['error_untyped'] })).rejects.toThrow('[unknown] error requested through Info request');
     });
     test('charlieUsesRegularOldWallet', async () => {
         const wallet = ethers.Wallet.createRandom();
         const charliesContext = await makeUserContextFromWallet(wallet);
         const charlie = await makeTestRpcClient();
         const userId = userIdFromAddress(charliesContext.creatorAddress);
-        const streamIdStr = makeUserStreamId(userId);
-        const streamId = streamIdToBytes(streamIdStr);
+        const streamId = streamIdToBytes(makeUserStreamId(userId));
         await charlie.createStream({
             events: [
                 await makeEvent(charliesContext, make_UserPayload_Inception({
-                    streamId: streamId,
+                    streamId,
                 })),
             ],
-            streamId: streamId,
+            streamId,
         });
     });
     test('bobSendsMismatchedPayloadCase', async () => {
-        log('bobSendsMismatchedPayloadCase', 'start');
         const bob = await makeTestRpcClient();
         const bobsUserId = userIdFromAddress(bobsContext.creatorAddress);
-        const bobsUserStreamIdStr = makeUserStreamId(bobsUserId);
-        const bobsUserStreamId = streamIdToBytes(bobsUserStreamIdStr);
+        const bobsUserStreamId = streamIdToBytes(makeUserStreamId(bobsUserId));
         const inceptionEvent = await makeEvent(bobsContext, make_UserPayload_Inception({
             streamId: bobsUserStreamId,
         }));
@@ -99,8 +66,7 @@ describe('streamRpcClient', () => {
         const userStream = await bob.getStream({ streamId: bobsUserStreamId });
         expect(userStream).toBeDefined();
         expect(bin_equal(userStream.stream?.nextSyncCookie?.streamId, bobsUserStreamId)).toBeTruthy();
-        // try to send a channel message
-        const event = await makeEvent(bobsContext, make_ChannelPayload_Message({
+        const event = await makeEvent(bobsContext, make_GDMChannelPayload_Message({
             ...TEST_ENCRYPTED_MESSAGE_PROPS,
             ciphertext: 'hello',
         }), userStream.stream?.miniblocks.at(-1)?.header?.hash);
@@ -108,8 +74,7 @@ describe('streamRpcClient', () => {
             streamId: bobsUserStreamId,
             event,
         });
-        await expect(promise).rejects.toThrow('inception type mismatch: *protocol.StreamEvent_ChannelPayload::*protocol.ChannelPayload_Message vs *protocol.UserPayload_Inception');
-        log('bobSendsMismatchedPayloadCase', 'done');
+        await expect(promise).rejects.toThrow('inception type mismatch');
     });
     test.each([
         ['bobTalksToHimself-noflush-nopresync', false],
@@ -117,192 +82,10 @@ describe('streamRpcClient', () => {
     ])('%s', async (name, presync) => {
         await bobTalksToHimself(log.extend(name), bobsContext, false, presync);
     });
-    test('aliceTalksToBob', async () => {
-        log('bobAndAliceConverse start');
-        const bob = await makeTestRpcClient();
-        const bobsUserId = userIdFromAddress(bobsContext.creatorAddress);
-        const bobsUserStreamIdStr = makeUserStreamId(bobsUserId);
-        const bobsUserStreamId = streamIdToBytes(bobsUserStreamIdStr);
-        const alice = await makeTestRpcClient();
-        const alicesUserId = userIdFromAddress(alicesContext.creatorAddress);
-        const alicesUserStreamIdStr = makeUserStreamId(alicesUserId);
-        const alicesUserStreamId = streamIdToBytes(alicesUserStreamIdStr);
-        // Create accounts for Bob and Alice
-        const bobsStream = await bob.createStream({
-            events: [
-                await makeEvent(bobsContext, make_UserPayload_Inception({
-                    streamId: bobsUserStreamId,
-                })),
-            ],
-            streamId: bobsUserStreamId,
-        });
-        const alicesStream = await alice.createStream({
-            events: [
-                await makeEvent(alicesContext, make_UserPayload_Inception({
-                    streamId: alicesUserStreamId,
-                })),
-            ],
-            streamId: alicesUserStreamId,
-        });
-        // Bob creates space
-        const spaceIdStr = makeUniqueSpaceStreamId();
-        const spaceId = streamIdToBytes(spaceIdStr);
-        const inceptionEvent = await makeEvent(bobsContext, make_SpacePayload_Inception({
-            streamId: spaceId,
-        }));
-        const joinEvent = await makeEvent(bobsContext, make_MemberPayload_Membership2({
-            userId: bobsUserId,
-            op: MembershipOp.SO_JOIN,
-            initiatorId: bobsUserId,
-        }));
-        await bob.createStream({
-            events: [inceptionEvent, joinEvent],
-            streamId: spaceId,
-        });
-        // Bob creates channel
-        const channelIdStr = makeUniqueChannelStreamId(spaceIdStr);
-        const channelId = streamIdToBytes(channelIdStr);
-        const channelInceptionEvent = await makeEvent(bobsContext, make_ChannelPayload_Inception({
-            streamId: channelId,
-        }));
-        let event = await makeEvent(bobsContext, make_MemberPayload_Membership2({
-            userId: bobsUserId,
-            op: MembershipOp.SO_JOIN,
-            initiatorId: bobsUserId,
-        }));
-        const createChannelResponse = await bob.createStream({
-            events: [channelInceptionEvent, event],
-            streamId: channelId,
-        });
-        // Bob succesdfully posts a message
-        event = await makeEvent(bobsContext, make_ChannelPayload_Message({
-            ...TEST_ENCRYPTED_MESSAGE_PROPS,
-            ciphertext: 'hello',
-        }), createChannelResponse.stream?.miniblocks.at(-1)?.header?.hash);
-        await bob.addEvent({
-            streamId: channelId,
-            event,
-        });
-        // Alice fails to post a message if she hasn't joined the channel
-        log("Alice fails to post a message if she hasn't joined the channel");
-        await expect(alice.addEvent({
-            streamId: channelId,
-            event: await makeEvent(alicesContext, make_ChannelPayload_Message({
-                ...TEST_ENCRYPTED_MESSAGE_PROPS,
-                ciphertext: 'hello',
-            }), createChannelResponse.stream?.miniblocks.at(-1)?.header?.hash),
-        })).rejects.toThrow(expect.objectContaining({
-            message: expect.stringContaining('7:PERMISSION_DENIED'),
-        }));
-        // Alice syncs her user stream waiting for invite
-        const userAlice = await alice.getStream({
-            streamId: alicesUserStreamId,
-        });
-        if (!userAlice.stream)
-            throw new Error('userAlice stream not found');
-        let aliceSyncCookie = userAlice.stream.nextSyncCookie;
-        const aliceSyncStreams = alice.syncStreams({
-            syncPos: aliceSyncCookie ? [aliceSyncCookie] : [],
-        }, {
-            timeoutMs: -1,
-            headers: { 'X-Use-Shared-Sync': 'true' },
-        });
-        let syncId;
-        log("Alice waits for Bob's channel creation event");
-        await expect(waitForSyncStreams(aliceSyncStreams, async (res) => {
-            syncId = res.syncId;
-            return res.syncOp === SyncOp.SYNC_NEW && res.syncId !== undefined;
-        })).resolves.not.toThrow();
-        // Bob invites Alice to the channel
-        log('Bob invites Alice to the channel');
-        event = await makeEvent(bobsContext, make_UserPayload_UserMembershipAction({
-            op: MembershipOp.SO_INVITE,
-            userId: addressFromUserId(alicesUserId),
-            streamId: channelId,
-        }), bobsStream.stream?.miniblocks.at(-1)?.header?.hash);
-        await bob.addEvent({
-            streamId: bobsUserStreamId,
-            event,
-        });
-        log("Alice waits for Bob's invite event");
-        aliceSyncCookie = await waitForEvent(aliceSyncStreams, alicesUserStreamIdStr, (e) => {
-            if (e.event.payload?.case === 'userPayload' &&
-                e.event.payload?.value.content.case === 'userMembership') {
-                log("Alice's received over sync:", {
-                    op: e.event.payload?.value.content.value.op,
-                    streamId: streamIdAsString(e.event.payload?.value.content.value.streamId),
-                    inviter: e.event.payload?.value.content.value.inviter,
-                    inviterId: e.event.payload?.value.content.value.inviter
-                        ? userIdFromAddress(e.event.payload?.value.content.value.inviter)
-                        : undefined,
-                    bob: bobsUserId,
-                    bobAddress: addressFromUserId(bobsUserId),
-                    bobAddress2: bobsContext.creatorAddress,
-                    bobAddress3: userIdFromAddress(bobsContext.creatorAddress),
-                    inviterEquals: bin_equal(e.event.payload?.value.content.value.inviter, bobsContext.creatorAddress),
-                    channelIdEquals: bin_equal(e.event.payload?.value.content.value.streamId, channelId),
-                    inviteEquals: e.event.payload?.value.content.value.op === MembershipOp.SO_INVITE,
-                });
-                return (e.event.payload?.value.content.value.op === MembershipOp.SO_INVITE &&
-                    bin_equal(e.event.payload?.value.content.value.streamId, channelId) &&
-                    bin_equal(e.event.payload?.value.content.value.inviter, bobsContext.creatorAddress));
-            }
-            return false;
-        });
-        // Alice joins the channel
-        event = await makeEvent(alicesContext, make_UserPayload_UserMembership({
-            op: MembershipOp.SO_JOIN,
-            streamId: channelId,
-        }), alicesStream.stream?.miniblocks.at(-1)?.header?.hash);
-        await alice.addEvent({
-            streamId: alicesUserStreamId,
-            event,
-        });
-        log('Alice waits for join event in her user stream');
-        // Alice sees derived join event in her user stream
-        aliceSyncCookie = await waitForEvent(aliceSyncStreams, alicesUserStreamIdStr, (e) => e.event.payload?.case === 'userPayload' &&
-            e.event.payload?.value.content.case === 'userMembership' &&
-            e.event.payload?.value.content.value.op === MembershipOp.SO_JOIN &&
-            bin_equal(e.event.payload?.value.content.value.streamId, channelId));
-        // Alice reads previouse messages from the channel
-        const channel = await alice.getStream({ streamId: channelId });
-        let messageCount = 0;
-        if (!channel.stream)
-            throw new Error('channel stream not found');
-        const envelopes = await unpackStreamEnvelopes(channel.stream, undefined);
-        envelopes.forEach((e) => {
-            const p = e.event.payload;
-            if (p?.case === 'channelPayload' && p.value.content.case === 'message') {
-                messageCount++;
-                expect(p.value.content.value.ciphertext).toEqual('hello');
-            }
-        });
-        expect(messageCount).toEqual(1);
-        await alice.modifySync({
-            syncId,
-            addStreams: [channel.stream.nextSyncCookie],
-        });
-        // Bob posts another message
-        event = await makeEvent(bobsContext, make_ChannelPayload_Message({
-            ...TEST_ENCRYPTED_MESSAGE_PROPS,
-            ciphertext: 'Hello, Alice!',
-        }), channel.stream?.miniblocks.at(-1)?.header?.hash);
-        await bob.addEvent({
-            streamId: channelId,
-            event,
-        });
-        log('Alice waits for Bob to post another message');
-        // Alice sees the message in the channel stream
-        await expect(waitForEvent(aliceSyncStreams, channelIdStr, (e) => e.event.payload?.case === 'channelPayload' &&
-            e.event.payload?.value.content.case === 'message' &&
-            e.event.payload?.value.content.value.ciphertext === 'Hello, Alice!')).resolves.not.toThrow();
-        await alice.cancelSync({ syncId });
-    });
     test.each([
         [0n, 'never'],
         [{ days: 2 }, 'in two days'],
-    ])('cantAddOrCreateWithExpiredDelegateSig expiry: %o expires %s', async (goodExpiry, desc) => {
-        log('testing with good expiry of', goodExpiry, 'which expires', desc);
+    ])('cantAddOrCreateWithExpiredDelegateSig expiry: %o expires %s', async (goodExpiry, _expiresDescription) => {
         const jimmy = await makeTestRpcClient();
         const jimmysWallet = ethers.Wallet.createRandom();
         const jimmysDelegateWallet = ethers.Wallet.createRandom();
@@ -322,16 +105,14 @@ describe('streamRpcClient', () => {
                 streamId: jimmysUserStreamId,
             });
         };
-        // test create stream
         await expect(makeUserStreamWith(jimmysExpiredContext)).rejects.toThrow(expect.objectContaining({
             message: expect.stringContaining('7:PERMISSION_DENIED'),
         }));
         await expect(makeUserStreamWith(jimmysGoodContext)).resolves.not.toThrow();
-        // create a space
-        const spacedStreamId = streamIdToBytes(makeUniqueSpaceStreamId());
-        const spaceEvents = await makeEvents(jimmysGoodContext, [
-            make_SpacePayload_Inception({
-                streamId: spacedStreamId,
+        const gdmId = streamIdToBytes(makeUniqueGDMChannelStreamId());
+        const gdmEvents = await makeEvents(jimmysGoodContext, [
+            make_GDMChannelPayload_Inception({
+                streamId: gdmId,
             }),
             make_MemberPayload_Membership2({
                 userId: jimmysUserId,
@@ -340,22 +121,20 @@ describe('streamRpcClient', () => {
             }),
         ]);
         await jimmy.createStream({
-            events: spaceEvents,
-            streamId: spacedStreamId,
+            events: gdmEvents,
+            streamId: gdmId,
         });
-        // try to leave, first with expired context, then with good context
         const addEventWith = async (context) => {
             const lastMiniblockHash = (await jimmy.getLastMiniblockHash({ streamId: jimmysUserStreamId })).hash;
-            const messageEvent = await makeEvent(context, make_UserPayload_UserMembership({
-                streamId: spacedStreamId,
+            const membershipEvent = await makeEvent(context, make_UserPayload_UserMembership({
+                streamId: gdmId,
                 op: MembershipOp.SO_LEAVE,
             }), lastMiniblockHash);
             return jimmy.addEvent({
                 streamId: jimmysUserStreamId,
-                event: messageEvent,
+                event: membershipEvent,
             });
         };
-        // test add event
         await expect(addEventWith(jimmysExpiredContext)).rejects.toThrow(expect.objectContaining({
             message: expect.stringContaining('7:PERMISSION_DENIED'),
         }));
@@ -364,8 +143,7 @@ describe('streamRpcClient', () => {
     test('cantAddWithBadHash', async () => {
         const bob = await makeTestRpcClient();
         const bobsUserId = userIdFromAddress(bobsContext.creatorAddress);
-        const bobsUserStreamIdStr = makeUserStreamId(bobsUserId);
-        const bobsUserStreamId = streamIdToBytes(bobsUserStreamIdStr);
+        const bobsUserStreamId = streamIdToBytes(makeUserStreamId(bobsUserId));
         await expect(bob.createStream({
             events: [
                 await makeEvent(bobsContext, make_UserPayload_Inception({
@@ -374,13 +152,10 @@ describe('streamRpcClient', () => {
             ],
             streamId: bobsUserStreamId,
         })).resolves.not.toThrow();
-        log('Bob created user, about to create space');
-        // Bob creates space and channel
-        const spacedStreamIdStr = makeUniqueSpaceStreamId();
-        const spacedStreamId = streamIdToBytes(spacedStreamIdStr);
-        const spaceEvents = await makeEvents(bobsContext, [
-            make_SpacePayload_Inception({
-                streamId: spacedStreamId,
+        const gdmId = streamIdToBytes(makeUniqueGDMChannelStreamId());
+        const gdmEvents = await makeEvents(bobsContext, [
+            make_GDMChannelPayload_Inception({
+                streamId: gdmId,
             }),
             make_MemberPayload_Membership2({
                 userId: bobsUserId,
@@ -389,60 +164,36 @@ describe('streamRpcClient', () => {
             }),
         ]);
         await bob.createStream({
-            events: spaceEvents,
-            streamId: spacedStreamId,
+            events: gdmEvents,
+            streamId: gdmId,
         });
-        log('Bob created space, about to create channel');
-        const channelIdStr = makeUniqueChannelStreamId(spacedStreamIdStr);
-        const channelId = streamIdToBytes(channelIdStr);
-        const channelEvents = await makeEvents(bobsContext, [
-            make_ChannelPayload_Inception({
-                streamId: channelId,
-            }),
-            make_MemberPayload_Membership2({
-                userId: bobsUserId,
-                op: MembershipOp.SO_JOIN,
-                initiatorId: bobsUserId,
-            }),
-        ]);
-        await bob.createStream({
-            events: channelEvents,
-            streamId: channelId,
-        });
-        log('Bob created channel');
-        log('Bob fails to create channel with badly chained initial events, hash empty');
-        const channelId2Str = makeUniqueChannelStreamId(spacedStreamIdStr);
-        const channelId2 = streamIdToBytes(channelId2Str);
-        const channelEvent2_0 = await makeEvent(bobsContext, make_ChannelPayload_Inception({
-            streamId: channelId2,
+        const gdmId2 = streamIdToBytes(makeUniqueGDMChannelStreamId());
+        const gdmEvent2_0 = await makeEvent(bobsContext, make_GDMChannelPayload_Inception({
+            streamId: gdmId2,
         }));
-        log('Bob fails to create channel with badly chained initial events, wrong hash value');
-        const channelEvent2_2 = await makeEvent(bobsContext, make_MemberPayload_Membership2({
+        const gdmEvent2_1 = await makeEvent(bobsContext, make_MemberPayload_Membership2({
             userId: bobsUserId,
             op: MembershipOp.SO_JOIN,
             initiatorId: bobsUserId,
-        }), Uint8Array.from(Array(32).fill('1')));
-        // TODO: fix up error codes Err.BAD_PREV_EVENTS
+        }), Uint8Array.from(Array(32).fill(1)));
         await expect(bob.createStream({
-            events: [channelEvent2_0, channelEvent2_2],
-            streamId: channelId2,
+            events: [gdmEvent2_0, gdmEvent2_1],
+            streamId: gdmId2,
         })).rejects.toThrow(expect.objectContaining({
             message: expect.stringContaining('19:BAD_STREAM_CREATION_PARAMS'),
         }));
-        log('Bob adds event with correct hash');
-        const lastMiniblockHash = (await bob.getLastMiniblockHash({ streamId: channelId })).hash;
-        const messageEvent = await makeEvent(bobsContext, make_ChannelPayload_Message({
+        const lastMiniblockHash = (await bob.getLastMiniblockHash({ streamId: gdmId })).hash;
+        const messageEvent = await makeEvent(bobsContext, make_GDMChannelPayload_Message({
             ...TEST_ENCRYPTED_MESSAGE_PROPS,
             ciphertext: 'Hello, World!',
         }), lastMiniblockHash);
         await expect(bob.addEvent({
-            streamId: channelId,
+            streamId: gdmId,
             event: messageEvent,
         })).resolves.not.toThrow();
-        log('Bob fails to add event with empty hash');
         await expect(bob.addEvent({
-            streamId: channelId,
-            event: await makeEvent_test(bobsContext, make_ChannelPayload_Message({
+            streamId: gdmId,
+            event: await makeEvent_test(bobsContext, make_GDMChannelPayload_Message({
                 ...TEST_ENCRYPTED_MESSAGE_PROPS,
                 ciphertext: 'Hello, World!',
             })),
@@ -453,8 +204,7 @@ describe('streamRpcClient', () => {
     test('cantAddWithBadSignature', async () => {
         const bob = await makeTestRpcClient();
         const bobsUserId = userIdFromAddress(bobsContext.creatorAddress);
-        const bobsUserStreamIdStr = makeUserStreamId(bobsUserId);
-        const bobsUserStreamId = streamIdToBytes(bobsUserStreamIdStr);
+        const bobsUserStreamId = streamIdToBytes(makeUserStreamId(bobsUserId));
         await expect(bob.createStream({
             events: [
                 await makeEvent(bobsContext, make_UserPayload_Inception({
@@ -463,30 +213,10 @@ describe('streamRpcClient', () => {
             ],
             streamId: bobsUserStreamId,
         })).resolves.not.toThrow();
-        log('Bob created user, about to create space');
-        // Bob creates space and channel
-        const spacedStreamIdStr = makeUniqueSpaceStreamId();
-        const spacedStreamId = streamIdToBytes(spacedStreamIdStr);
-        const spaceEvents = await makeEvents(bobsContext, [
-            make_SpacePayload_Inception({
-                streamId: spacedStreamId,
-            }),
-            make_MemberPayload_Membership2({
-                userId: bobsUserId,
-                op: MembershipOp.SO_JOIN,
-                initiatorId: bobsUserId,
-            }),
-        ]);
-        await bob.createStream({
-            events: spaceEvents,
-            streamId: spacedStreamId,
-        });
-        log('Bob created space, about to create channel');
-        const channelIdStr = makeUniqueChannelStreamId(spacedStreamIdStr);
-        const channelId = streamIdToBytes(channelIdStr);
-        const channelEvents = await makeEvents(bobsContext, [
-            make_ChannelPayload_Inception({
-                streamId: channelId,
+        const gdmId = streamIdToBytes(makeUniqueGDMChannelStreamId());
+        const gdmEvents = await makeEvents(bobsContext, [
+            make_GDMChannelPayload_Inception({
+                streamId: gdmId,
             }),
             make_MemberPayload_Membership2({
                 userId: bobsUserId,
@@ -495,60 +225,39 @@ describe('streamRpcClient', () => {
             }),
         ]);
         await bob.createStream({
-            events: channelEvents,
-            streamId: channelId,
+            events: gdmEvents,
+            streamId: gdmId,
         });
-        log('Bob created channel');
-        log('Bob adds event with correct signature');
-        const lastMiniblockHash = (await bob.getLastMiniblockHash({ streamId: channelId })).hash;
-        const messageEvent = await makeEvent(bobsContext, make_ChannelPayload_Message({
+        const lastMiniblockHash = (await bob.getLastMiniblockHash({ streamId: gdmId })).hash;
+        const messageEvent = await makeEvent(bobsContext, make_GDMChannelPayload_Message({
             ...TEST_ENCRYPTED_MESSAGE_PROPS,
             ciphertext: 'Hello, World!',
         }), lastMiniblockHash);
-        channelEvents.push(messageEvent);
         await expect(bob.addEvent({
-            streamId: channelId,
+            streamId: gdmId,
             event: messageEvent,
         })).resolves.not.toThrow();
-        log('Adding event again succeeds (noop)');
         await expect(bob.addEvent({
-            streamId: channelId,
+            streamId: gdmId,
             event: messageEvent,
         })).resolves.not.toThrow();
-        log('Bob failes to add event with bad signature');
-        const badEvent = await makeEvent(bobsContext, make_ChannelPayload_Message({
+        const badEvent = await makeEvent(bobsContext, make_GDMChannelPayload_Message({
             ...TEST_ENCRYPTED_MESSAGE_PROPS,
             ciphertext: 'Nah, not really',
         }), lastMiniblockHash);
         badEvent.signature = messageEvent.signature;
         await expect(bob.addEvent({
-            streamId: channelId,
+            streamId: gdmId,
             event: badEvent,
         })).rejects.toThrow('22:BAD_EVENT_SIGNATURE');
-        log('Bob fails with outdated prev minibloc hash');
-        const expiredEvent = await makeEvent(bobsContext, make_ChannelPayload_Message({
+        const expiredEvent = await makeEvent(bobsContext, make_GDMChannelPayload_Message({
             ...TEST_ENCRYPTED_MESSAGE_PROPS,
             ciphertext: 'Nah, not really',
-        }), Uint8Array.from(Array(32).fill('1')));
+        }), Uint8Array.from(Array(32).fill(1)));
         await expect(bob.addEvent({
-            streamId: channelId,
+            streamId: gdmId,
             event: expiredEvent,
         })).rejects.toThrow('24:BAD_PREV_MINIBLOCK_HASH');
     });
 });
-const waitForEvent = async (syncStream, streamId, matcher) => {
-    for await (const res of iterableWrapper(syncStream)) {
-        const stream = res.stream;
-        if (stream?.nextSyncCookie?.streamId &&
-            bin_equal(stream.nextSyncCookie.streamId, streamIdToBytes(streamId))) {
-            const events = await unpackStreamEnvelopes(stream, undefined);
-            for (const e of events) {
-                if (matcher(e)) {
-                    return stream.nextSyncCookie;
-                }
-            }
-        }
-    }
-    throw new Error('unreachable');
-};
 //# sourceMappingURL=streamRpcClient.test.js.map