@towns-labs/sdk 2.0.11 → 2.0.13

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

@@ -1,622 +1,54 @@
-/**
- * @group main
- */
-import { MemberPayload_NftSchema } from '@towns-labs/proto';
-import { makeUniqueChannelStreamId, userIdFromAddress } from '../../id';
-import { makeDonePromise, makeRandomUserAddress, makeTestClient, makeUniqueSpaceStreamId, waitFor, } from '../testUtils';
-import { make_MemberPayload_Nft } from '../../types';
-import { bin_fromString, bin_toString } from '@towns-labs/utils';
-import { create } from '@bufbuild/protobuf';
+import { makeDonePromise, makeTestClient } from '../testUtils';
 describe('memberMetadataTests', () => {
     let bobsClient;
     let alicesClient;
-    let evesClient;
     beforeEach(async () => {
         bobsClient = await makeTestClient();
         alicesClient = await makeTestClient();
-        evesClient = await makeTestClient();
+        await Promise.all([bobsClient.initializeUser(), alicesClient.initializeUser()]);
     });
     afterEach(async () => {
         await bobsClient.stop();
         await alicesClient.stop();
-        await evesClient.stop();
-    });
-    test('clientCanSetDisplayNamesInSpace', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        await bobsClient.inviteUser(streamId, alicesClient.userId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        await bobsClient.waitForStream(streamId);
-        await alicesClient.waitForStream(streamId);
-        await bobsClient.setDisplayName(streamId, 'bob');
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        const expected = new Map([[bobsClient.userId, 'bob']]);
-        for (const client of [bobsClient, alicesClient]) {
-            const streamView = client.streams.get(streamId).view;
-            expect(streamView.getMemberMetadata().displayNames.plaintextDisplayNames).toEqual(expected);
-        }
     });
     test('clientDoesntHaveAppAddress', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        const streamView = bobsClient.streams.get(streamId).view;
-        expect(streamView.getMemberMetadata().userInfo(bobsClient.userId).appAddress).toEqual(undefined);
-    });
-    test('clientCanSetDisplayNamesInDM', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        const { streamId } = await bobsClient.createDMChannel(alicesClient.userId);
-        const stream = await bobsClient.waitForStream(streamId);
-        await alicesClient.waitForStream(streamId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await waitFor(() => {
-            expect(stream.view.getMembers().joinedUsers).toEqual(new Set([bobsClient.userId, alicesClient.userId]));
-        });
-        const bobDisplayName = 'bob display name';
-        await expect(bobsClient.setDisplayName(streamId, bobDisplayName)).resolves.not.toThrow();
-        const expected = new Map([[bobsClient.userId, bobDisplayName]]);
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        for (const client of [bobsClient, alicesClient]) {
-            const streamView = client.streams.get(streamId)?.view;
-            expect(streamView).toBeDefined();
-            const clientDisplayNames = streamView.getMemberMetadata().displayNames.plaintextDisplayNames;
-            expect(clientDisplayNames).toEqual(expected);
-        }
-    });
-    test('clientCanSetDisplayNamesInGDM', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        await expect(evesClient.initializeUser()).resolves.not.toThrow();
-        evesClient.startSync();
         const { streamId } = await bobsClient.createGDMChannel([
+            { userId: bobsClient.userId },
             { userId: alicesClient.userId },
-            { userId: evesClient.userId },
         ]);
-        const stream = await bobsClient.waitForStream(streamId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await expect(evesClient.joinStream(streamId)).resolves.not.toThrow();
-        await waitFor(() => {
-            expect(stream.view.getMembers().joinedUsers).toEqual(new Set([bobsClient.userId, alicesClient.userId, evesClient.userId]));
-        });
-        const bobDisplayName = 'bob display name';
-        await expect(bobsClient.setDisplayName(streamId, bobDisplayName)).resolves.not.toThrow();
-        const expected = new Map([[bobsClient.userId, bobDisplayName]]);
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        const evePromise = makeDonePromise();
-        evesClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            evePromise.done();
-        });
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        await evePromise.expectToSucceed();
-        for (const client of [bobsClient, alicesClient, evesClient]) {
-            const streamView = client.streams.get(streamId)?.view;
-            expect(streamView).toBeDefined();
-            const clientDisplayNames = streamView.getMemberMetadata().displayNames.plaintextDisplayNames;
-            expect(clientDisplayNames).toEqual(expected);
-        }
-    });
-    test('clientsPickUpDisplayNamesAfterJoin', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
         await bobsClient.waitForStream(streamId);
-        await bobsClient.setDisplayName(streamId, 'bob');
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        await bobsClient.inviteUser(streamId, alicesClient.userId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamDisplayNameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        await alicePromise.expectToSucceed();
-        const expected = new Map([[bobsClient.userId, 'bob']]);
-        const alicesClientDisplayNames = alicesClient.streams.get(streamId)?.view.membershipContent.memberMetadata.displayNames
-            .plaintextDisplayNames;
-        expect(alicesClientDisplayNames).toEqual(expected);
-    });
-    test('clientCanSetUsernamesInSpaces', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        await bobsClient.inviteUser(streamId, alicesClient.userId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        const startTime = Date.now();
-        let usernameSetTime = null;
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            usernameSetTime = Date.now();
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        const setUsernamePromise = bobsClient.setUsername(streamId, 'bob-username');
-        const expected = new Map([[bobsClient.userId, 'bob-username']]);
-        // expect username to get updated immediately
-        expect(bobsClient.streams.get(streamId).view.getMemberMetadata().usernames.plaintextUsernames).toEqual(expected);
-        expect(bobsClient.streams
-            .get(streamId)
-            .view.getMemberMetadata()
-            .usernames.info(bobsClient.userId).username).toEqual('bob-username');
-        // wait for the username request to send
-        await setUsernamePromise;
-        // wait for the username to be updated
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        // Verify that setting the username was not delayed — see `setUsername delays` for details
-        const elapsed = usernameSetTime - startTime;
-        expect(elapsed).toBeLessThanOrEqual(10000);
-        for (const client of [bobsClient, alicesClient]) {
-            const streamView = client.streams.get(streamId).view;
-            expect(streamView.getMemberMetadata().usernames.plaintextUsernames).toEqual(expected);
-            expect(streamView.getMemberMetadata().usernames.info(bobsClient.userId).username).toEqual('bob-username');
-        }
-    });
-    test('clientCanSetUsernamesInDMs', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        const { streamId } = await bobsClient.createDMChannel(alicesClient.userId);
-        const stream = await bobsClient.waitForStream(streamId);
-        await alicesClient.waitForStream(streamId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await waitFor(() => {
-            expect(stream.view.getMembers().joinedUsers).toEqual(new Set([bobsClient.userId, alicesClient.userId]));
-        });
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        await bobsClient.setUsername(streamId, 'bob-username');
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        const expected = new Map([[bobsClient.userId, 'bob-username']]);
-        for (const client of [bobsClient, alicesClient]) {
-            const streamView = client.streams.get(streamId).view;
-            expect(streamView.getMemberMetadata()?.usernames.plaintextUsernames).toEqual(expected);
-            expect(streamView.getMemberMetadata()?.userInfo(client.userId).appAddress).toBeUndefined();
-        }
-    });
-    test('clientCanSetUsernamesInGDMs', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        await expect(evesClient.initializeUser()).resolves.not.toThrow();
-        evesClient.startSync();
-        const { streamId } = await bobsClient.createGDMChannel([
-            { userId: alicesClient.userId },
-            { userId: evesClient.userId },
-        ]);
-        const stream = await bobsClient.waitForStream(streamId);
-        await alicesClient.waitForStream(streamId);
-        await evesClient.waitForStream(streamId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await expect(evesClient.joinStream(streamId)).resolves.not.toThrow();
-        await waitFor(() => {
-            expect(stream.view.getMembers().joinedUsers).toEqual(new Set([bobsClient.userId, alicesClient.userId, evesClient.userId]));
-        });
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        const evePromise = makeDonePromise();
-        evesClient.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            evePromise.done();
-        });
-        await bobsClient.setUsername(streamId, 'bob-username');
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        await evePromise.expectToSucceed();
-        const expected = new Map([[bobsClient.userId, 'bob-username']]);
-        for (const client of [bobsClient, alicesClient, evesClient]) {
-            const streamView = client.streams.get(streamId).view;
-            expect(streamView.getMemberMetadata().usernames.plaintextUsernames).toEqual(expected);
-        }
-    });
-    test('clientCanSetEnsAddressesInSpace', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        await bobsClient.inviteUser(streamId, alicesClient.userId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await alicesClient.waitForStream(streamId);
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamEnsAddressUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamEnsAddressUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        const ensAddress = makeRandomUserAddress();
-        await bobsClient.setEnsAddress(streamId, ensAddress);
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        const expected = new Map([
-            [bobsClient.userId, userIdFromAddress(ensAddress)],
-        ]);
-        for (const client of [bobsClient, alicesClient]) {
-            const streamView = client.streams.get(streamId).view;
-            expect(streamView.getMemberMetadata().ensAddresses.confirmedEnsAddresses).toEqual(expected);
-        }
-    });
-    test('clientCanSetEnsAddressesInDM', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        const { streamId } = await bobsClient.createDMChannel(alicesClient.userId);
-        const stream = await bobsClient.waitForStream(streamId);
-        await alicesClient.waitForStream(streamId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await waitFor(() => {
-            expect(stream.view.getMembers().joinedUsers).toEqual(new Set([bobsClient.userId, alicesClient.userId]));
-        });
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamEnsAddressUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamEnsAddressUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        const ensAddress = makeRandomUserAddress();
-        await expect(bobsClient.setEnsAddress(streamId, ensAddress)).resolves.not.toThrow();
-        const expected = new Map([
-            [bobsClient.userId, userIdFromAddress(ensAddress)],
-        ]);
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        for (const client of [bobsClient, alicesClient]) {
-            const streamView = client.streams.get(streamId)?.view;
-            expect(streamView).toBeDefined();
-            const ensAddresses = streamView.getMemberMetadata().ensAddresses.confirmedEnsAddresses;
-            expect(ensAddresses).toEqual(expected);
-        }
+        const streamView = bobsClient.streams.get(streamId).view;
+        expect(streamView.getMemberMetadata().userInfo(bobsClient.userId).appAddress).toEqual(undefined);
     });
-    test('clientCanSetEnsAddressesInGDM', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
+    test('clientCanSetStreamEncryptionAlgorithm', async () => {
         bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        await expect(evesClient.initializeUser()).resolves.not.toThrow();
-        evesClient.startSync();
         const { streamId } = await bobsClient.createGDMChannel([
+            { userId: bobsClient.userId },
             { userId: alicesClient.userId },
-            { userId: evesClient.userId },
-        ]);
-        const stream = await bobsClient.waitForStream(streamId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await expect(evesClient.joinStream(streamId)).resolves.not.toThrow();
-        await waitFor(() => {
-            expect(stream.view.getMembers().joinedUsers).toEqual(new Set([bobsClient.userId, alicesClient.userId, evesClient.userId]));
-        });
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamEnsAddressUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamEnsAddressUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        const evePromise = makeDonePromise();
-        evesClient.on('streamEnsAddressUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            evePromise.done();
-        });
-        const ensAddress = makeRandomUserAddress();
-        await expect(bobsClient.setEnsAddress(streamId, ensAddress)).resolves.not.toThrow();
-        const expected = new Map([
-            [bobsClient.userId, userIdFromAddress(ensAddress)],
         ]);
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        await evePromise.expectToSucceed();
-        for (const client of [bobsClient, alicesClient, evesClient]) {
-            const streamView = client.streams.get(streamId)?.view;
-            expect(streamView).toBeDefined();
-            const ensAddresses = streamView.getMemberMetadata().ensAddresses.confirmedEnsAddresses;
-            expect(ensAddresses).toEqual(expected);
-        }
-    });
-    test('clientCannotSetInvalidEnsAddresses', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
         await bobsClient.waitForStream(streamId);
-        const ensAddress = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
-        await expect(bobsClient.setEnsAddress(streamId, ensAddress)).rejects.toThrow(/Invalid ENS address/);
-    });
-    test('clientCanClearEnsAddress', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        const ensAddress = new Uint8Array();
-        await expect(bobsClient.setEnsAddress(streamId, ensAddress)).resolves.not.toThrow();
-    });
-    test('clientCanSetNftInSpace', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        await bobsClient.inviteUser(streamId, alicesClient.userId);
-        await expect(alicesClient.joinStream(streamId)).resolves.not.toThrow();
-        await alicesClient.waitForStream(streamId);
-        const bobPromise = makeDonePromise();
-        bobsClient.on('streamNftUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            bobPromise.done();
-        });
-        const alicePromise = makeDonePromise();
-        alicesClient.on('streamNftUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(bobsClient.userId);
-            alicePromise.done();
-        });
-        const nft = create(MemberPayload_NftSchema, {
-            chainId: 1,
-            tokenId: bin_fromString('11111111112222222233333333'),
-            contractAddress: makeRandomUserAddress(),
-        });
-        await bobsClient.setNft(streamId, bin_toString(nft.tokenId), 1, userIdFromAddress(nft.contractAddress));
-        await bobPromise.expectToSucceed();
-        await alicePromise.expectToSucceed();
-        const expected = new Map([[bobsClient.userId, nft]]);
-        for (const client of [bobsClient, alicesClient]) {
-            const streamView = client.streams.get(streamId).view;
-            expect(streamView.getMemberMetadata().nfts.confirmedNfts).toEqual(expected);
-            const bobInfo = streamView.getMemberMetadata().nfts.info(bobsClient.userId);
-            expect(bobInfo?.tokenId).toEqual('11111111112222222233333333');
-        }
-    });
-    test('clientCannotSetNftsInvalidContractAddress', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        const nft = create(MemberPayload_NftSchema, {
-            chainId: 1,
-            tokenId: bin_fromString('123'),
-            contractAddress: new Uint8Array([1, 2, 3]),
-        });
-        await expect(bobsClient.makeEventAndAddToStream(streamId, make_MemberPayload_Nft(nft))).rejects.toThrow('invalid contract address');
-    });
-    test('clientCannotSetNftsInvalidChainId', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        const nft = create(MemberPayload_NftSchema, {
-            chainId: 0,
-            tokenId: bin_fromString('123'),
-            contractAddress: makeRandomUserAddress(),
-        });
-        await expect(bobsClient.makeEventAndAddToStream(streamId, make_MemberPayload_Nft(nft))).rejects.toThrow('invalid chain id');
-    });
-    test('clientCannotSetNftsInvalidTokenId', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        const nft = create(MemberPayload_NftSchema, {
-            chainId: 1,
-            tokenId: new Uint8Array(),
-            contractAddress: makeRandomUserAddress(),
-        });
-        await expect(bobsClient.makeEventAndAddToStream(streamId, make_MemberPayload_Nft(nft))).rejects.toThrow('invalid token id');
-    });
-    test('clientCanClearNft', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await bobsClient.createSpace(streamId);
-        await bobsClient.waitForStream(streamId);
-        await expect(bobsClient.setNft(streamId, '', 0, '')).resolves.not.toThrow();
-    });
-    test('clientCanSetStreamEncryptionAlgorithm', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        const spaceId = makeUniqueSpaceStreamId();
-        const channelId = makeUniqueChannelStreamId(spaceId);
-        await bobsClient.createSpace(spaceId);
-        await bobsClient.waitForStream(spaceId);
-        await bobsClient.createChannel(spaceId, 'secret channel', 'messaging like spies', channelId);
-        await bobsClient.waitForStream(channelId);
         // initial value is "undefined"
-        expect(bobsClient.stream(channelId)?.view.membershipContent.encryptionAlgorithm).toBe(undefined);
+        expect(bobsClient.stream(streamId)?.view.membershipContent.encryptionAlgorithm).toBe(undefined);
         const newAlgorithm = 'mega_v1';
         const truePromise = makeDonePromise();
         bobsClient.once('streamEncryptionAlgorithmUpdated', (updatedStreamId, value) => {
-            expect(updatedStreamId).toBe(channelId);
+            expect(updatedStreamId).toBe(streamId);
             expect(value).toBe(newAlgorithm);
             truePromise.done();
         });
-        await expect(bobsClient.setStreamEncryptionAlgorithm(channelId, newAlgorithm)).resolves.not.toThrow();
+        await expect(bobsClient.setStreamEncryptionAlgorithm(streamId, newAlgorithm)).resolves.not.toThrow();
         await truePromise.expectToSucceed();
-        expect(bobsClient.stream(channelId)?.view.membershipContent.encryptionAlgorithm).toBe(newAlgorithm);
+        expect(bobsClient.stream(streamId)?.view.membershipContent.encryptionAlgorithm).toBe(newAlgorithm);
         // toggle back to to undefined
         const falsePromise = makeDonePromise();
         bobsClient.once('streamEncryptionAlgorithmUpdated', (updatedStreamId, value) => {
-            expect(updatedStreamId).toBe(channelId);
+            expect(updatedStreamId).toBe(streamId);
             expect(value).toBe(undefined);
             falsePromise.done();
         });
-        await expect(bobsClient.setStreamEncryptionAlgorithm(channelId, undefined)).resolves.not.toThrow();
+        await expect(bobsClient.setStreamEncryptionAlgorithm(streamId, undefined)).resolves.not.toThrow();
         await falsePromise.expectToSucceed();
-        expect(bobsClient.stream(channelId)?.view.membershipContent.encryptionAlgorithm).toBe(undefined);
-    });
-    test('setUsername delays for large groups without hybrid session', async () => {
-        await expect(bobsClient.initializeUser()).resolves.not.toThrow();
-        bobsClient.startSync();
-        await expect(alicesClient.initializeUser()).resolves.not.toThrow();
-        alicesClient.startSync();
-        // Create client
-        const clientWithSettings = await makeTestClient();
-        await clientWithSettings.initializeUser();
-        clientWithSettings.startSync();
-        const streamId = makeUniqueSpaceStreamId();
-        await clientWithSettings.createSpace(streamId);
-        await clientWithSettings.waitForStream(streamId);
-        // Add more members to exceed threshold
-        await alicesClient.joinStream(streamId);
-        await bobsClient.joinStream(streamId);
-        await waitFor(() => {
-            expect(clientWithSettings.streams.get(streamId)?.view.membershipContent.joined.size).toBe(3);
-        });
-        // Mock hasHybridSession to return false
-        clientWithSettings['cryptoBackend'].hasHybridSession = async () => false;
-        const startTime = Date.now();
-        let usernameSetTime = null;
-        let pendingUsernameSetTime = null;
-        const streamUsernameUpdated = makeDonePromise();
-        clientWithSettings.on('streamUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(clientWithSettings.userId);
-            usernameSetTime = Date.now();
-            streamUsernameUpdated.done();
-        });
-        const streamPendingUsernameUpdated = makeDonePromise();
-        clientWithSettings.once('streamPendingUsernameUpdated', (updatedStreamId, userId) => {
-            expect(updatedStreamId).toBe(streamId);
-            expect(userId).toBe(clientWithSettings.userId);
-            pendingUsernameSetTime = Date.now();
-            streamPendingUsernameUpdated.done();
-        });
-        // Should not set immediately - will be delayed
-        await clientWithSettings.setUsername(streamId, 'delayed-username', false, {
-            largeGroupThreshold: 2, // Low threshold for testing
-            delayMs: 2000, // 2 seconds for faster testing
-        });
-        const stream = clientWithSettings.streams.get(streamId);
-        expect(stream.view
-            .getMemberMetadata()
-            .usernames.plaintextUsernames.get(clientWithSettings.userId)).toBe('delayed-username');
-        // Verify timeout was set
-        expect(clientWithSettings['pendingUsernameTimeouts'].has(streamId)).toBe(true);
-        expect(clientWithSettings['pendingUsernames'].get(streamId)).toBe('delayed-username');
-        await streamPendingUsernameUpdated.expectToSucceed();
-        // Wait for the delayed set
-        await streamUsernameUpdated.expectToSucceed();
-        // Verify it was delayed by approximately the configured time
-        const elapsed = usernameSetTime - startTime;
-        expect(elapsed).toBeGreaterThanOrEqual(2000);
-        const pendingUsernameElapsed = pendingUsernameSetTime - startTime;
-        expect(pendingUsernameElapsed).toBeLessThanOrEqual(100);
-        expect(clientWithSettings['pendingUsernameTimeouts'].has(streamId)).toBe(false);
-        expect(clientWithSettings['pendingUsernames'].get(streamId)).toBe(undefined);
-        await clientWithSettings.stop();
+        expect(bobsClient.stream(streamId)?.view.membershipContent.encryptionAlgorithm).toBe(undefined);
     });
 });
 //# sourceMappingURL=memberMetadata.test.js.map