@towns-labs/sdk 2.0.11 → 2.0.13

package/dist/client.js

@@ -1,21 +1,21 @@
 import { create, toBinary, toJsonString } from '@bufbuild/protobuf';
 import { SpaceAddressFromSpaceId, SpaceReviewAction, } from '@towns-labs/web3';
-import { MembershipOp, ChannelOp, Err, BlockchainTransactionReceipt_LogSchema, BlockchainTransactionReceiptSchema, ChannelPropertiesSchema, FullyReadMarkersSchema, ChunkedMediaSchema, EncryptedDataSchema, UserBioSchema, MemberPayload_NftSchema, ChannelMessageSchema, SolanaBlockchainTransactionReceiptSchema, SessionKeysSchema, EnvelopeSchema, MessageInteractionType, InteractionRequestPayloadSchema, InteractionResponsePayloadSchema, EncryptedDataVersion, } from '@towns-labs/proto';
-import { bin_fromHexString, bin_toHexString, shortenHexString, check, dlog, dlogError, bin_fromString, bin_toBase64, } from '@towns-labs/utils';
-import { AES_GCM_DERIVED_ALGORITHM, EncryptionAlgorithmId, GroupEncryptionAlgorithmId, GroupEncryptionCrypto, } from '@towns-labs/encryption';
+import { MembershipOp, Err, BlockchainTransactionReceipt_LogSchema, BlockchainTransactionReceiptSchema, ChannelPropertiesSchema, FullyReadMarkersSchema, ChunkedMediaSchema, EncryptedDataSchema, UserBioSchema, ChannelMessageSchema, SolanaBlockchainTransactionReceiptSchema, SessionKeysSchema, EnvelopeSchema, MessageInteractionType, InteractionRequestPayloadSchema, InteractionResponsePayloadSchema, EncryptedDataVersion, } from '@towns-labs/proto';
+import { bin_fromHexString, bin_toHexString, shortenHexString, check, dlog, dlogError, bin_toBase64, } from '@towns-labs/utils';
+import { AES_GCM_DERIVED_ALGORITHM, EncryptionAlgorithmId, GroupEncryptionAlgorithmId, GroupEncryptionCrypto, parseGroupEncryptionAlgorithmId, } from '@towns-labs/encryption';
 import { makeSessionKeys, } from './decryptionExtensions';
 import { ClientDecryptionExtensions } from './clientDecryptionExtensions';
 import { getMaxTimeoutMs, getMiniblocks } from './makeStreamRpcClient';
 import { errorContains, errorContainsMessage, getRpcErrorProperty } from './rpcInterceptors';
 import { assert, isDefined, logNever } from './check';
 import EventEmitter from 'events';
-import { isChannelStreamId, isDMChannelStreamId, isGDMChannelStreamId, isSpaceStreamId, makeDMStreamId, makeUniqueGDMChannelStreamId, makeUniqueMediaStreamId, makeUserMetadataStreamId, makeUserSettingsStreamId, makeUserStreamId, makeUserInboxStreamId, userIdFromAddress, addressFromUserId, streamIdAsBytes, streamIdAsString, makeSpaceStreamId, STREAM_ID_STRING_LENGTH, contractAddressFromSpaceId, isUserId, spaceIdFromChannelId, } from './id';
+import { isGDMChannelStreamId, makeUniqueGDMChannelStreamId, makeUniqueMediaStreamId, makeUserMetadataStreamId, makeUserSettingsStreamId, makeUserStreamId, makeUserInboxStreamId, userIdFromAddress, addressFromUserId, streamIdAsBytes, streamIdAsString, isUserId, } from './id';
 import { makeEvent, unpackStream, unpackStreamEx, waitForStreamEx, } from './sign';
 import { StreamStateView } from './streamStateView';
-import { make_UserMetadataPayload_Inception, make_ChannelPayload_Inception, make_ChannelPayload_Message, make_MemberPayload_Membership2, make_SpacePayload_Inception, make_UserPayload_Inception, make_SpacePayload_ChannelUpdate, make_UserSettingsPayload_FullyReadMarkers, make_UserSettingsPayload_UserBlock, make_UserSettingsPayload_Inception, make_MediaPayload_Inception, make_MediaPayload_Chunk, make_DMChannelPayload_Inception, make_DMChannelPayload_Message, make_GDMChannelPayload_Inception, make_GDMChannelPayload_Message, make_UserInboxPayload_Ack, make_UserInboxPayload_Inception, make_UserMetadataPayload_EncryptionDevice, make_UserInboxPayload_GroupEncryptionSessions, make_GDMChannelPayload_ChannelProperties, make_UserPayload_UserMembershipAction, make_UserPayload_UserMembership, make_MemberPayload_DisplayName, make_MemberPayload_Username, getRefEventIdFromChannelMessage, make_payload_Redaction, make_MemberPayload_EnsAddress, make_MemberPayload_Nft, make_MemberPayload_Pin, make_MemberPayload_Unpin, make_SpacePayload_UpdateChannelAutojoin, make_SpacePayload_UpdateChannelHideUserJoinLeaveEvents, make_SpacePayload_SpaceImage, make_UserMetadataPayload_ProfileImage, make_UserMetadataPayload_Bio, make_UserPayload_BlockchainTransaction, make_MemberPayload_EncryptionAlgorithm, isSolanaTransactionReceipt, make_payload_InteractionRequest, make_payload_InteractionResponse, } from './types';
+import { make_UserMetadataPayload_Inception, make_MemberPayload_Membership2, make_UserPayload_Inception, make_UserSettingsPayload_FullyReadMarkers, make_UserSettingsPayload_UserBlock, make_UserSettingsPayload_Inception, make_MediaPayload_Inception, make_MediaPayload_Chunk, make_GDMChannelPayload_Inception, make_GDMChannelPayload_Message, make_UserInboxPayload_Ack, make_UserInboxPayload_Inception, make_UserMetadataPayload_EncryptionDevice, make_UserInboxPayload_GroupEncryptionSessions, make_GDMChannelPayload_ChannelProperties, make_UserPayload_UserMembershipAction, make_UserPayload_UserMembership, getRefEventIdFromChannelMessage, make_payload_Redaction, make_MemberPayload_Pin, make_MemberPayload_Unpin, make_UserMetadataPayload_ProfileImage, make_UserMetadataPayload_Bio, make_UserPayload_BlockchainTransaction, make_MemberPayload_EncryptionAlgorithm, isSolanaTransactionReceipt, make_payload_InteractionRequest, make_payload_InteractionResponse, } from './types';
 import { applyExclusionFilterToMiniblocks } from './streamUtils';
 import debug from 'debug';
-import { ethereumAddressAsBytes, getTime, isEthereumAddress, stripUndefinedMetadata, usernameChecksum, } from './utils';
+import { ethereumAddressAsBytes, getTime, isEthereumAddress } from './utils';
 import { isEncryptedContentKind, toDecryptedContent } from './encryptedContentTypes';
 import { PersistenceStore, StubPersistenceStore, } from './persistenceStore';
 import { SyncedStreams } from './syncedStreams';
@@ -76,8 +76,6 @@ export class Client extends EventEmitter {
     syncedStreamsExtensions;
     persistenceStore;
     defaultGroupEncryptionAlgorithm;
-    pendingUsernames = new Map();
-    pendingUsernameTimeouts = new Map();
     constructor(signerContext, appAddress, rpcClient, cryptoStore, opts) {
         super();
         this.opts = opts;
@@ -93,7 +91,7 @@ export class Client extends EventEmitter {
         this.userId = userIdFromAddress(signerContext.creatorAddress);
         this.appAddress = appAddress;
         this.streamsView = new StreamsView(this.userId, {
-            isDMMessageEventBlocked: (event) => {
+            isGDMMessageEventBlocked: (event) => {
                 if (!this?.userSettingsStreamId) {
                     return false;
                 }
@@ -183,8 +181,7 @@ export class Client extends EventEmitter {
         this.on('streamUpToDate', (s) => void this.onStreamUpToDate(s));
         const streamIds = Object.entries(stream.view.userContent.streamMemberships).reduce((acc, [streamId, payload]) => {
             if (payload?.op === MembershipOp.SO_JOIN ||
-                (payload?.op === MembershipOp.SO_INVITE &&
-                    (isDMChannelStreamId(streamId) || isGDMChannelStreamId(streamId)))) {
+                (payload?.op === MembershipOp.SO_INVITE && isGDMChannelStreamId(streamId))) {
                 acc.push(streamId);
             }
             return acc;
@@ -199,27 +196,16 @@ export class Client extends EventEmitter {
         const appOwnerAddress = opts?.appOwnerAddress
             ? ethereumAddressAsBytes(opts.appOwnerAddress)
             : undefined;
-        if (opts?.installedAppAddress && !isEthereumAddress(opts.installedAppAddress)) {
-            throw Error('installedAppAddress must be an ethereum address');
-        }
-        const spaceId = opts?.spaceId ? streamIdAsBytes(opts?.spaceId) : undefined;
-        const installedAppAddress = opts?.installedAppAddress
-            ? ethereumAddressAsBytes(opts.installedAppAddress)
-            : undefined;
-        const initMetadata = {
-            spaceId,
-            installedAppAddress,
-        };
         const initializeUserStartTime = performance.now();
         this.logCall('initializeUser', this.userId);
         assert(this.userStreamId === undefined, 'already initialized');
         const initCrypto = await getTime(() => this.initCrypto(opts?.encryptionDeviceInit));
         check(isDefined(this.decryptionExtensions), 'decryptionExtensions must be defined');
         const [initUserStream, initUserInboxStream, initUserMetadataStream, initUserSettingsStream,] = await Promise.all([
-            getTime(() => this.initUserStream(initMetadata, appOwnerAddress)),
-            getTime(() => this.initUserInboxStream(initMetadata, appOwnerAddress)),
-            getTime(() => this.initUserMetadataStream(initMetadata, appOwnerAddress)),
-            getTime(() => this.initUserSettingsStream(initMetadata, appOwnerAddress)),
+            getTime(() => this.initUserStream({ appOwnerAddress })),
+            getTime(() => this.initUserInboxStream({ appOwnerAddress })),
+            getTime(() => this.initUserMetadataStream({ appOwnerAddress })),
+            getTime(() => this.initUserSettingsStream({ appOwnerAddress })),
         ]);
         this.initUserJoinedStreams();
         if (!opts?.skipSync) {
@@ -243,27 +229,27 @@ export class Client extends EventEmitter {
     onNetworkStatusChanged(isOnline) {
         this.streams.onNetworkStatusChanged(isOnline);
     }
-    async initUserStream(metadata, appOwnerAddress) {
+    async initUserStream(args) {
         this.userStreamId = makeUserStreamId(this.userId);
         const userStream = this.createSyncedStream(this.userStreamId);
         if (!(await userStream.initializeFromPersistence())) {
             const response = (await this.getUserStream(this.userStreamId)) ??
-                (await this.createUserStream(this.userStreamId, metadata, appOwnerAddress));
+                (await this.createUserStream(this.userStreamId, args));
             await userStream.initializeFromResponse(response);
         }
         check(userStream.view.userContent.appAddress === this.appAddress, 'appAddress mismatch after initializing user stream');
     }
-    async initUserInboxStream(metadata, appOwnerAddress) {
+    async initUserInboxStream(args) {
         this.userInboxStreamId = makeUserInboxStreamId(this.userId);
         const userInboxStream = this.createSyncedStream(this.userInboxStreamId);
         if (!(await userInboxStream.initializeFromPersistence())) {
             const response = (await this.getUserStream(this.userInboxStreamId)) ??
-                (await this.createUserInboxStream(this.userInboxStreamId, metadata, appOwnerAddress));
+                (await this.createUserInboxStream(this.userInboxStreamId, args));
             await userInboxStream.initializeFromResponse(response);
         }
         check(userInboxStream.view.userInboxContent.appAddress === this.appAddress, 'appAddress mismatch after initializing user inbox stream');
     }
-    async initUserMetadataStream(metadata, appOwnerAddress) {
+    async initUserMetadataStream(args) {
         this.userMetadataStreamId = makeUserMetadataStreamId(this.userId);
         const userMetadataStream = this.createSyncedStream(this.userMetadataStreamId);
         let initUserMetadataStreamInitFromPersistenceTime = 0;
@@ -285,7 +271,7 @@ export class Client extends EventEmitter {
             else {
                 const createUserMetadataStreamResponse = await getTime(() => {
                     check(!!this.userMetadataStreamId, 'userMetadataStreamId must be set');
-                    return this.createUserMetadataStream(this.userMetadataStreamId, metadata, appOwnerAddress);
+                    return this.createUserMetadataStream(this.userMetadataStreamId, args);
                 });
                 initUserMetadataStreamCreateUserMetadataStreamTime =
                     createUserMetadataStreamResponse.time;
@@ -313,12 +299,12 @@ export class Client extends EventEmitter {
         };
         return times;
     }
-    async initUserSettingsStream(metadata, appOwnerAddress) {
+    async initUserSettingsStream(args) {
         this.userSettingsStreamId = makeUserSettingsStreamId(this.userId);
         const userSettingsStream = this.createSyncedStream(this.userSettingsStreamId);
         if (!(await userSettingsStream.initializeFromPersistence())) {
             const response = (await this.getUserStream(this.userSettingsStreamId)) ??
-                (await this.createUserSettingsStream(this.userSettingsStreamId, metadata, appOwnerAddress));
+                (await this.createUserSettingsStream(this.userSettingsStreamId, args));
             await userSettingsStream.initializeFromResponse(response);
         }
         check(userSettingsStream.view.userSettingsContent.appAddress === this.appAddress, 'appAddress mismatch after initializing user settings stream');
@@ -335,7 +321,8 @@ export class Client extends EventEmitter {
             return undefined;
         }
     }
-    async createUserStream(userStreamId, metadata, appOwnerAddress) {
+    async createUserStream(userStreamId, args) {
+        const { appOwnerAddress } = args;
         check(isDefined(this.appAddress) == isDefined(appOwnerAddress), 'appAddress and appOwnerAddress must both be set or both be undefined');
         const userEvents = [
             await makeEvent(this.signerContext, make_UserPayload_Inception({
@@ -344,15 +331,15 @@ export class Client extends EventEmitter {
                 appOwnerAddress,
             })),
         ];
-        const encoded = metadata ? stripUndefinedMetadata(metadata) : metadata;
         const response = await this.rpcClient.createStream({
             events: userEvents,
             streamId: streamIdAsBytes(userStreamId),
-            metadata: encoded,
+            metadata: undefined,
         });
         return unpackStream(response.stream, this.opts?.unpackEnvelopeOpts);
     }
-    async createUserMetadataStream(userMetadataStreamId, metadata, appOwnerAddress) {
+    async createUserMetadataStream(userMetadataStreamId, args) {
+        const { appOwnerAddress } = args;
         check(isDefined(this.appAddress) == isDefined(appOwnerAddress), 'appAddress and appOwnerAddress must both be set or both be undefined');
         const userDeviceKeyEvents = [
             await makeEvent(this.signerContext, make_UserMetadataPayload_Inception({
@@ -361,15 +348,15 @@ export class Client extends EventEmitter {
                 appOwnerAddress,
             })),
         ];
-        const encoded = metadata ? stripUndefinedMetadata(metadata) : metadata;
         const response = await this.rpcClient.createStream({
             events: userDeviceKeyEvents,
             streamId: streamIdAsBytes(userMetadataStreamId),
-            metadata: encoded,
+            metadata: undefined,
         });
         return unpackStream(response.stream, this.opts?.unpackEnvelopeOpts);
     }
-    async createUserInboxStream(userInboxStreamId, metadata, appOwnerAddress) {
+    async createUserInboxStream(userInboxStreamId, args) {
+        const { appOwnerAddress } = args;
         check(isDefined(this.appAddress) == isDefined(appOwnerAddress), 'appAddress and appOwnerAddress must both be set or both be undefined');
         const userInboxEvents = [
             await makeEvent(this.signerContext, make_UserInboxPayload_Inception({
@@ -378,15 +365,15 @@ export class Client extends EventEmitter {
                 appOwnerAddress,
             })),
         ];
-        const encoded = metadata ? stripUndefinedMetadata(metadata) : metadata;
         const response = await this.rpcClient.createStream({
             events: userInboxEvents,
             streamId: streamIdAsBytes(userInboxStreamId),
-            metadata: encoded,
+            metadata: undefined,
         });
         return unpackStream(response.stream, this.opts?.unpackEnvelopeOpts);
     }
-    async createUserSettingsStream(inUserSettingsStreamId, metadata, appOwnerAddress) {
+    async createUserSettingsStream(inUserSettingsStreamId, args) {
+        const { appOwnerAddress } = args;
         check(isDefined(this.appAddress) == isDefined(appOwnerAddress), 'appAddress and appOwnerAddress must both be set or both be undefined');
         const userSettingsStreamId = streamIdAsBytes(inUserSettingsStreamId);
         const userSettingsEvents = [
@@ -396,11 +383,10 @@ export class Client extends EventEmitter {
                 appOwnerAddress,
             })),
         ];
-        const encoded = metadata ? stripUndefinedMetadata(metadata) : metadata;
         const response = await this.rpcClient.createStream({
             events: userSettingsEvents,
             streamId: userSettingsStreamId,
-            metadata: encoded,
+            metadata: undefined,
         });
         return unpackStream(response.stream, this.opts?.unpackEnvelopeOpts);
     }
@@ -429,83 +415,20 @@ export class Client extends EventEmitter {
         }
         return { streamId: streamId };
     }
-    // createSpace
-    // param spaceAddress: address of the space contract, or address made with makeSpaceStreamId
     async createSpace(spaceAddressOrId) {
-        const oSpaceId = spaceAddressOrId.length === STREAM_ID_STRING_LENGTH
-            ? spaceAddressOrId
-            : makeSpaceStreamId(spaceAddressOrId);
-        const spaceId = streamIdAsBytes(oSpaceId);
-        this.logCall('createSpace', spaceId);
-        assert(this.userStreamId !== undefined, 'streamId must be set');
-        assert(isSpaceStreamId(spaceId), 'spaceId must be a valid streamId');
-        // create utf8 encoder
-        const inceptionEvent = await makeEvent(this.signerContext, make_SpacePayload_Inception({
-            streamId: spaceId,
-        }));
-        const joinEvent = await makeEvent(this.signerContext, make_MemberPayload_Membership2({
-            userId: this.userId,
-            op: MembershipOp.SO_JOIN,
-            initiatorId: this.userId,
-        }));
-        return this.createStreamAndSync({
-            events: [inceptionEvent, joinEvent],
-            streamId: spaceId,
-            metadata: {},
-        });
+        this.logCall('createSpace', spaceAddressOrId);
+        throw new Error('Space streams are not supported');
     }
     async createChannel(spaceId, _channelName, _channelTopic, inChannelId, streamSettings, channelSettings) {
-        const channelId = streamIdAsBytes(inChannelId);
-        const channelIdStr = streamIdAsString(inChannelId);
-        const spaceIdstr = streamIdAsString(spaceId);
-        this.logCall('createChannel', channelId, spaceId);
-        const derivedSpaceId = spaceIdFromChannelId(channelIdStr);
-        assert(derivedSpaceId === spaceIdstr, 'derivedSpaceId must be the same as spaceId');
-        assert(this.userStreamId !== undefined, 'userStreamId must be set');
-        assert(isSpaceStreamId(spaceId), 'spaceId must be a valid streamId');
-        assert(isChannelStreamId(channelId), 'channelId must be a valid streamId');
-        const inceptionEvent = await makeEvent(this.signerContext, make_ChannelPayload_Inception({
-            streamId: channelId,
-            settings: streamSettings,
-            channelSettings: channelSettings,
-        }));
-        const joinEvent = await makeEvent(this.signerContext, make_MemberPayload_Membership2({
-            userId: this.userId,
-            op: MembershipOp.SO_JOIN,
-            initiatorId: this.userId,
-        }));
-        return this.createStreamAndSync({
-            events: [inceptionEvent, joinEvent],
-            streamId: channelId,
-            metadata: {},
-        });
+        this.logCall('createChannel', streamIdAsString(inChannelId), streamIdAsString(spaceId));
+        void streamSettings;
+        void channelSettings;
+        throw new Error('Channel streams are not supported');
     }
     async createDMChannel(userId, appAddress, streamSettings) {
-        const channelIdStr = makeDMStreamId(this.userId, userId);
-        const channelId = streamIdAsBytes(channelIdStr);
-        const inceptionEvent = await makeEvent(this.signerContext, make_DMChannelPayload_Inception({
-            streamId: channelId,
-            firstPartyAddress: this.signerContext.creatorAddress,
-            secondPartyAddress: addressFromUserId(userId),
-            secondPartyAppAddress: appAddress ? bin_fromHexString(appAddress) : undefined,
-            settings: streamSettings,
-        }));
-        const joinEvent = await makeEvent(this.signerContext, make_MemberPayload_Membership2({
-            userId: this.userId,
-            op: MembershipOp.SO_JOIN,
-            initiatorId: this.userId,
-        }));
-        const inviteEvent = await makeEvent(this.signerContext, make_MemberPayload_Membership2({
-            userId: userId,
-            op: MembershipOp.SO_JOIN,
-            initiatorId: this.userId,
-            appAddress,
-        }));
-        return this.createStreamAndSync({
-            events: [inceptionEvent, joinEvent, inviteEvent],
-            streamId: channelId,
-            metadata: {},
-        });
+        this.logCall('createDMChannel', userId, appAddress);
+        void streamSettings;
+        throw new Error('DM streams are not supported');
     }
     async createGDMChannel(users, channelProperties, streamSettings) {
         const channelIdStr = makeUniqueGDMChannelStreamId();
@@ -545,12 +468,10 @@ export class Client extends EventEmitter {
             throw Error('channelId, spaceId or userId must be set');
         }
         if (spaceId) {
-            assert(isSpaceStreamId(spaceId), 'spaceId must be a valid streamId');
+            throw Error('spaceId is not supported for media streams');
         }
         if (channelId) {
-            assert(isChannelStreamId(channelId) ||
-                isDMChannelStreamId(channelId) ||
-                isGDMChannelStreamId(channelId), 'channelId must be a valid streamId');
+            assert(isGDMChannelStreamId(channelId), 'channelId must be a valid GDM streamId');
         }
         if (userId) {
             assert(isUserId(userId), 'userId must be a valid userId');
@@ -562,7 +483,7 @@ export class Client extends EventEmitter {
         events.push(await makeEvent(this.signerContext, make_MediaPayload_Inception({
             streamId: streamIdAsBytes(streamId),
             channelId: channelId ? streamIdAsBytes(channelId) : undefined,
-            spaceId: spaceId ? streamIdAsBytes(spaceId) : undefined,
+            spaceId: undefined,
             userId: userId ? addressFromUserId(userId) : undefined,
             chunkCount,
             settings: streamSettings,
@@ -585,33 +506,15 @@ export class Client extends EventEmitter {
     }
     async updateChannel(spaceId, channelId, unused1, unused2) {
         this.logCall('updateChannel', channelId, spaceId, unused1, unused2);
-        assert(isSpaceStreamId(spaceId), 'spaceId must be a valid streamId');
-        assert(isChannelStreamId(channelId), 'channelId must be a valid streamId');
-        return this.makeEventAndAddToStream(spaceId, // we send events to the stream of the space where updated channel belongs to
-        make_SpacePayload_ChannelUpdate({
-            op: ChannelOp.CO_UPDATED,
-            channelId: streamIdAsBytes(channelId),
-        }), { method: 'updateChannel' });
+        throw new Error('Channel streams are not supported');
     }
     async updateChannelAutojoin(spaceId, channelId, autojoin) {
         this.logCall('updateChannelAutojoin', channelId, spaceId, autojoin);
-        assert(isSpaceStreamId(spaceId), 'spaceId must be a valid streamId');
-        assert(isChannelStreamId(channelId), 'channelId must be a valid streamId');
-        return this.makeEventAndAddToStream(spaceId, // we send events to the stream of the space where updated channel belongs to
-        make_SpacePayload_UpdateChannelAutojoin({
-            channelId: streamIdAsBytes(channelId),
-            autojoin: autojoin,
-        }), { method: 'updateChannelAutojoin' });
+        throw new Error('Channel streams are not supported');
     }
     async updateChannelHideUserJoinLeaveEvents(spaceId, channelId, hideUserJoinLeaveEvents) {
         this.logCall('updateChannelHideUserJoinLeaveEvents', channelId, spaceId, hideUserJoinLeaveEvents);
-        assert(isSpaceStreamId(spaceId), 'spaceId must be a valid streamId');
-        assert(isChannelStreamId(channelId), 'channelId must be a valid streamId');
-        return this.makeEventAndAddToStream(spaceId, // we send events to the stream of the space where updated channel belongs to
-        make_SpacePayload_UpdateChannelHideUserJoinLeaveEvents({
-            channelId: streamIdAsBytes(channelId),
-            hideUserJoinLeaveEvents,
-        }), { method: 'updateChannelHideUserJoinLeaveEvents' });
+        throw new Error('Channel streams are not supported');
     }
     async updateGDMChannelProperties(streamId, channelName, channelTopic) {
         this.logCall('updateGDMChannelProperties', streamId, channelName, channelTopic);
@@ -628,10 +531,7 @@ export class Client extends EventEmitter {
         });
     }
     async setStreamEncryptionAlgorithm(streamId, encryptionAlgorithm) {
-        assert(isChannelStreamId(streamId) ||
-            isSpaceStreamId(streamId) ||
-            isDMChannelStreamId(streamId) ||
-            isGDMChannelStreamId(streamId), 'channelId must be a valid streamId');
+        assert(isGDMChannelStreamId(streamId), 'streamId must be a valid GDM streamId');
         const stream = this.stream(streamId);
         check(isDefined(stream), 'stream not found');
         check(stream.view.membershipContent.encryptionAlgorithm != encryptionAlgorithm, `encryptionAlgorithm is already set to ${encryptionAlgorithm}`);
@@ -657,15 +557,11 @@ export class Client extends EventEmitter {
         if (!isDefined(this.userSettingsStreamId)) {
             throw Error('userSettingsStreamId is not defined');
         }
-        const dmStreamId = makeDMStreamId(this.userId, userId);
         const lastBlock = this.stream(this.userSettingsStreamId)?.view.userSettingsContent.getLastBlock(userId);
         if (lastBlock?.isBlocked === isBlocked) {
             throw Error(`updateUserBlock isBlocked<${isBlocked}> must be different from existing value`);
         }
-        let eventNum = this.stream(dmStreamId)?.view.lastEventNum ?? 0n;
-        if (lastBlock && lastBlock.eventNum >= eventNum) {
-            eventNum = lastBlock.eventNum + 1n;
-        }
+        const eventNum = (lastBlock?.eventNum ?? 0n) + 1n;
         return this.makeEventAndAddToStream(this.userSettingsStreamId, make_UserSettingsPayload_UserBlock({
             userId: addressFromUserId(userId),
             isBlocked: isBlocked,
@@ -674,20 +570,7 @@ export class Client extends EventEmitter {
     }
     async setSpaceImage(spaceStreamId, chunkedMediaInfo) {
         this.logCall('setSpaceImage', spaceStreamId, chunkedMediaInfo.streamId, chunkedMediaInfo.info);
-        // create the chunked media to be added
-        const spaceAddress = contractAddressFromSpaceId(spaceStreamId);
-        const context = spaceAddress.toLowerCase();
-        // encrypt the chunked media
-        // use the lowercased spaceId as the key phrase
-        const { key, iv } = await deriveKeyAndIV(context);
-        const { ciphertext } = await encryptAESGCM(toBinary(ChunkedMediaSchema, create(ChunkedMediaSchema, chunkedMediaInfo)), key, iv);
-        const encryptedData = create(EncryptedDataSchema, {
-            ciphertext: uint8ArrayToBase64(ciphertext),
-            algorithm: AES_GCM_DERIVED_ALGORITHM,
-        }); // aellis this should probably include `satisfies PlainMessage<EncryptedData>`
-        // add the event to the stream
-        const event = make_SpacePayload_SpaceImage(encryptedData);
-        return this.makeEventAndAddToStream(spaceStreamId, event, { method: 'setSpaceImage' });
+        throw new Error('Space streams are not supported');
     }
     async setUserProfileImage(chunkedMediaInfo, userId) {
         this.logCall('setUserProfileImage', userId, chunkedMediaInfo.streamId, chunkedMediaInfo.info);
@@ -739,79 +622,6 @@ export class Client extends EventEmitter {
         const streamId = makeUserMetadataStreamId(userId);
         return this.stream(streamId)?.view.userMetadataContent.getBio();
     }
-    async setDisplayName(streamId, displayName) {
-        check(isDefined(this.cryptoBackend));
-        const encryptedData = await this.cryptoBackend.encryptGroupEvent(streamId, new TextEncoder().encode(displayName), this.defaultGroupEncryptionAlgorithm);
-        await this.makeEventAndAddToStream(streamId, make_MemberPayload_DisplayName(encryptedData), { method: 'displayName' });
-    }
-    async setUsername(streamId, username, force = false, options) {
-        check(isDefined(this.cryptoBackend));
-        check(username.length > 0, 'username cannot be empty');
-        const stream = this.stream(streamId);
-        check(isDefined(stream), 'stream not found');
-        // Clear any existing timeout first
-        const existingTimeout = this.pendingUsernameTimeouts.get(streamId);
-        if (existingTimeout) {
-            clearTimeout(existingTimeout);
-            this.pendingUsernameTimeouts.delete(streamId);
-        }
-        stream.view.getMemberMetadata().usernames.setLocalUsername(this.userId, username, this);
-        // be very careful about setting a username for a large group, we don't want to inject
-        // more sessions than needed into the group. unless a session has been received in 60 seconds,
-        // we will force set the username.
-        const memberCount = stream.view.membershipContent.joined.size;
-        const hasHybridSession = (await this.cryptoBackend?.hasHybridSession?.(streamId)) ?? false;
-        const largeGroupThreshold = options?.largeGroupThreshold ?? 100;
-        const delayMs = options?.delayMs ?? 60000;
-        if (memberCount > largeGroupThreshold && !hasHybridSession && !force) {
-            this.pendingUsernames.set(streamId, username);
-            const timeout = setTimeout(() => {
-                void this.setUsername(streamId, username, true, options);
-            }, delayMs);
-            this.pendingUsernameTimeouts.set(streamId, timeout);
-            return;
-        }
-        // Clean up pending state
-        this.pendingUsernames.delete(streamId);
-        this.pendingUsernameTimeouts.delete(streamId);
-        try {
-            const encryptedData = await this.cryptoBackend.encryptGroupEvent(streamId, new TextEncoder().encode(username), this.defaultGroupEncryptionAlgorithm);
-            encryptedData.checksum = usernameChecksum(username, streamId);
-            await this.makeEventAndAddToStream(streamId, make_MemberPayload_Username(encryptedData), { method: 'username' });
-        }
-        catch (err) {
-            stream.view.getMemberMetadata().usernames.resetLocalUsername(this.userId);
-            // Clean up pending state on error
-            this.pendingUsernames.delete(streamId);
-            this.pendingUsernameTimeouts.delete(streamId);
-            throw err;
-        }
-    }
-    async setPendingUsernames() {
-        await Promise.all(Array.from(this.pendingUsernames.entries()).map(([streamId, pendingUsername]) => {
-            this.pendingUsernames.delete(streamId);
-            return this.setUsername(streamId, pendingUsername);
-        }));
-    }
-    async setEnsAddress(streamId, walletAddress) {
-        check(isDefined(this.cryptoBackend));
-        const bytes = typeof walletAddress === 'string' ? addressFromUserId(walletAddress) : walletAddress;
-        await this.makeEventAndAddToStream(streamId, make_MemberPayload_EnsAddress(bytes), {
-            method: 'ensAddress',
-        });
-    }
-    async setNft(streamId, tokenId, chainId, contractAddress) {
-        const payload = tokenId.length > 0
-            ? create(MemberPayload_NftSchema, {
-                chainId: chainId,
-                contractAddress: bin_fromHexString(contractAddress),
-                tokenId: bin_fromString(tokenId),
-            })
-            : create(MemberPayload_NftSchema);
-        await this.makeEventAndAddToStream(streamId, make_MemberPayload_Nft(payload), {
-            method: 'nft',
-        });
-    }
     async getPersistedEvent(streamId, eventId) {
         const timelineEvent = this.streamsView.timelinesView.value.timelines[streamId]?.find((e) => e.eventId === eventId);
         if (!timelineEvent) {
@@ -865,11 +675,6 @@ export class Client extends EventEmitter {
         });
         return result;
     }
-    isUsernameAvailable(streamId, username) {
-        const stream = this.streams.get(streamId);
-        check(isDefined(stream), 'stream not found');
-        return (stream.view.getMemberMetadata().usernames.cleartextUsernameAvailable(username) ?? false);
-    }
     async waitForStream(inStreamId, opts) {
         this.logCall('waitForStream', inStreamId);
         const timeoutMs = opts?.timeoutMs ?? getMaxTimeoutMs(this.rpcClient.opts);
@@ -1054,7 +859,7 @@ export class Client extends EventEmitter {
     };
     onInvitedToStream = async (streamId) => {
         this.logEvent('onInvitedToStream', streamId);
-        if (isDMChannelStreamId(streamId) || isGDMChannelStreamId(streamId)) {
+        if (isGDMChannelStreamId(streamId)) {
             await this.initStream(streamId);
         }
     };
@@ -1062,39 +867,7 @@ export class Client extends EventEmitter {
         this.logEvent('onLeftStream', streamId);
         return await this.streams.removeStreamFromSync(streamId);
     };
-    onStreamUpToDate = (streamId) => {
-        // we're migrating away from the old megolm based encryption to the new `grpaes` encryption,
-        // this is to avoid too many active crypto sessions active in the same stream
-        // this function will:
-        // - check if the user's username is encrypted with the old algorithm
-        // - check if the user has a hybrid session ready to go (hasHybridSession)
-        // - re-encrypt the username with the new algorithm
-        const updateUsernameEncryptionIfNeeded = async () => {
-            if (!isSpaceStreamId(streamId)) {
-                return;
-            }
-            const hasHybridSession = (await this.cryptoBackend?.hasHybridSession(streamId)) ?? false;
-            if (!hasHybridSession) {
-                return;
-            }
-            const stream = this.stream(streamId);
-            if (!stream) {
-                return;
-            }
-            const currentUsernameEncryptedData = stream.view.membershipContent.memberMetadata.usernames.currentUsernameEncryptedData;
-            if (!currentUsernameEncryptedData ||
-                currentUsernameEncryptedData.algorithm ===
-                    GroupEncryptionAlgorithmId.HybridGroupEncryption) {
-                return;
-            }
-            const currentUsername = stream.view.membershipContent.memberMetadata.usernames.info(this.userId);
-            if (!currentUsername || currentUsername.username.length === 0) {
-                return;
-            }
-            await this.setUsername(streamId, currentUsername.username);
-        };
-        void updateUsernameEncryptionIfNeeded();
-    };
+    onStreamUpToDate = (_streamId) => { };
     startSync() {
         this.syncedStreamsExtensions.setStartSyncRequested(true);
     }
@@ -1157,23 +930,7 @@ export class Client extends EventEmitter {
             throw new Error('failed to encrypt message');
         }
         message.refEventId = getRefEventIdFromChannelMessage(payload);
-        if (isChannelStreamId(streamId)) {
-            return this.makeEventAndAddToStream(streamId, make_ChannelPayload_Message(message), {
-                method: 'sendMessage',
-                localId,
-                cleartext,
-                tags,
-            });
-        }
-        else if (isDMChannelStreamId(streamId)) {
-            return this.makeEventAndAddToStream(streamId, make_DMChannelPayload_Message(message), {
-                method: 'sendMessageDM',
-                localId,
-                cleartext,
-                tags,
-            });
-        }
-        else if (isGDMChannelStreamId(streamId)) {
+        if (isGDMChannelStreamId(streamId)) {
             return this.makeEventAndAddToStream(streamId, make_GDMChannelPayload_Message(message), {
                 method: 'sendMessageGDM',
                 localId,
@@ -1181,9 +938,7 @@ export class Client extends EventEmitter {
                 tags,
             });
         }
-        else {
-            throw new Error(`invalid streamId: ${streamId}`);
-        }
+        throw new Error(`invalid streamId: ${streamId}`);
     }
     async sendChannelMessage_Text(streamId, payload, opts) {
         const { content, ...options } = payload;
@@ -1230,6 +985,21 @@ export class Client extends EventEmitter {
             },
         }, opts);
     }
+    async sendChannelMessage_ConversationSeedResponse(streamId, payload, opts) {
+        const { content, ...options } = payload;
+        return this.sendChannelMessage(streamId, {
+            payload: {
+                case: 'post',
+                value: {
+                    ...options,
+                    content: {
+                        case: 'conversationSeedResponse',
+                        value: content,
+                    },
+                },
+            },
+        }, opts);
+    }
     async sendMediaPayload(creationCookie, last, data, chunkIndex, iv) {
         const payload = make_MediaPayload_Chunk({
             data: data,
@@ -1480,16 +1250,6 @@ export class Client extends EventEmitter {
     async leaveStream(streamId) {
         this.logCall('leaveStream', streamId);
         check(isDefined(this.userStreamId));
-        if (isSpaceStreamId(streamId)) {
-            const channelIds = Object.keys(this.stream(streamId)?.view.spaceContent.spaceChannelsMetadata ?? {});
-            const userStream = this.stream(this.userStreamId);
-            for (const channelId of channelIds) {
-                if (userStream?.view.userContent.streamMemberships[channelId]?.op ===
-                    MembershipOp.SO_JOIN) {
-                    await this.leaveStream(channelId);
-                }
-            }
-        }
         return this.makeEventAndAddToStream(this.userStreamId, make_UserPayload_UserMembership({
             op: MembershipOp.SO_LEAVE,
             streamId: streamIdAsBytes(streamId),
@@ -1498,25 +1258,6 @@ export class Client extends EventEmitter {
     async removeUser(streamId, userId) {
         check(isDefined(this.userStreamId));
         this.logCall('removeUser', streamId, userId);
-        if (isSpaceStreamId(streamId)) {
-            const channelIds = Object.keys(this.stream(streamId)?.view.spaceContent.spaceChannelsMetadata ?? {});
-            const userStreamId = makeUserStreamId(userId);
-            const userStream = await this.getStream(userStreamId);
-            for (const channelId of channelIds) {
-                if (userStream.userContent.streamMemberships[channelId]?.op === MembershipOp.SO_JOIN) {
-                    try {
-                        await this.removeUser(channelId, userId);
-                    }
-                    catch (error) {
-                        this.logError('Failed to remove user from channel', {
-                            channelId,
-                            userId,
-                            error,
-                        });
-                    }
-                }
-            }
-        }
         return this.makeEventAndAddToStream(this.userStreamId, make_UserPayload_UserMembershipAction({
             op: MembershipOp.SO_LEAVE,
             userId: addressFromUserId(userId),
@@ -1976,6 +1717,50 @@ export class Client extends EventEmitter {
         check(isDefined(this.cryptoBackend), 'crypto backend not initialized');
         return this.cryptoBackend.ensureOutboundSession(streamId, this.defaultGroupEncryptionAlgorithm, opts);
     }
+    async exportInviteEncryptionData(inStreamId) {
+        const streamId = streamIdAsString(inStreamId);
+        await this.ensureOutboundSession(streamId);
+        check(isDefined(this.cryptoBackend), 'crypto backend not initialized');
+        const sessionIds = await this.cryptoBackend.getGroupSessionIds(streamId);
+        const sessions = [];
+        for (const sessionId of sessionIds) {
+            const session = await this.cryptoBackend.exportGroupSession(streamId, sessionId);
+            if (session) {
+                sessions.push(session);
+            }
+        }
+        check(sessions.length > 0, 'no group sessions found for stream');
+        check(new Set(sessions.map((session) => session.algorithm)).size === 1, 'group sessions must all use the same algorithm');
+        return {
+            streamId: streamIdAsBytes(streamId),
+            algorithm: sessions[0].algorithm,
+            sessions: sessions.map((session) => ({
+                sessionId: session.sessionId,
+                sessionKey: session.sessionKey,
+            })),
+        };
+    }
+    async importInviteEncryptionData(inStreamId, inviteEncryptionData) {
+        const streamId = streamIdAsString(inStreamId);
+        check(isDefined(this.cryptoBackend), 'crypto backend not initialized');
+        check(isDefined(inviteEncryptionData), 'invite encryption data is required');
+        const inviteStreamId = streamIdAsString(inviteEncryptionData.streamId);
+        check(inviteStreamId === streamId, 'invite encryption stream id must match target stream');
+        check(inviteEncryptionData.sessions.length > 0, 'invite encryption data must contain at least one session');
+        const parsedAlgorithm = parseGroupEncryptionAlgorithmId(inviteEncryptionData.algorithm);
+        check(parsedAlgorithm.kind === 'matched', `unsupported invite encryption algorithm: ${inviteEncryptionData.algorithm}`);
+        const sessions = inviteEncryptionData.sessions.map((session, index) => {
+            check(session.sessionId !== '', `invite encryption session ${index} is missing sessionId`);
+            check(session.sessionKey !== '', `invite encryption session ${index} is missing sessionKey`);
+            return {
+                streamId,
+                sessionId: session.sessionId,
+                sessionKey: session.sessionKey,
+                algorithm: parsedAlgorithm.value,
+            };
+        });
+        await this.cryptoBackend.importSessionKeys(streamId, sessions);
+    }
     /**
      * decrypts and updates the decrypted event
      */