@towns-labs/sdk 2.0.11 → 2.0.13

package/dist/tests/testUtils.js

@@ -2,10 +2,10 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { _impl_makeEvent_impl_, unpackStreamEnvelopes } from '../sign';
-import { MembershipOp, SyncOp, EncryptedDataVersion, } from '@towns-labs/proto';
+import { SyncOp, EncryptedDataVersion, } from '@towns-labs/proto';
 import { Client } from '../client';
 import { townsEnv } from '../townsEnv';
-import { genId, makeSpaceStreamId, makeDefaultChannelStreamId, makeUniqueChannelStreamId, makeUserStreamId, userIdFromAddress, } from '../id';
+import { genId, makeUniqueGDMChannelStreamId, userIdFromAddress } from '../id';
 import { secp256k1 } from '@noble/curves/secp256k1';
 import { bin_fromHexString, check, dlog, publicKeyToAddress } from '@towns-labs/utils';
 import { ethers } from 'ethers';
@@ -13,14 +13,10 @@ import { RiverDbManager } from '../riverDbManager';
 import { makeStreamRpcClient } from '../makeStreamRpcClient';
 import { forEachRight } from 'lodash-es';
 import { makeSignerContext } from '../signerContext';
-import { LocalhostWeb3Provider, createExternalNFTStruct, createSpaceDapp, Permission, isLegacyMembershipType, ETH_ADDRESS, NoopRuleData, CheckOperationType, LogicalOperationType, OperationType, treeToRuleData, TestERC20, TestERC1155, TestCrossChainEntitlement, isCreateLegacySpaceParams, convertRuleDataV1ToV2, encodeRuleDataV2, decodeRuleDataV2, isRuleDataV1, encodeThresholdParams, encodeERC1155Params, convertRuleDataV2ToV1, getFixedPricingModule, getDynamicPricingModule, } from '@towns-labs/web3';
+import { LocalhostWeb3Provider } from '@towns-labs/web3';
 import { RiverTimelineEvent } from '../views/models/timelineTypes';
-import { SyncState } from '../syncedStreamsLoop';
 import { isDefined } from '../check';
 const log = dlog('csb:test:util');
-function useLegacySpaces() {
-    return process.env.USE_LEGACY_SPACES === 'true';
-}
 const initTestUrls = async () => {
     const config = townsEnv().makeRiverChainConfig();
     const urls = townsEnv().getNodeUrl();
@@ -76,66 +72,12 @@ export const TEST_ENCRYPTED_MESSAGE_PROPS = {
     ivBytes: new Uint8Array(0),
     version: EncryptedDataVersion.ENCRYPTED_DATA_VERSION_1,
 };
-export const getXchainConfigForTesting = () => {
-    // TODO: generate this for test environment and read from it
-    return {
-        supportedRpcUrls: {
-            31337: 'http://127.0.0.1:8545',
-            31338: 'http://127.0.0.1:8546',
-        },
-        etherNativeNetworkIds: [31337, 31338],
-        ethereumNetworkIds: [],
-    };
-};
-export async function erc1155CheckOp(contractName, tokenId, threshold) {
-    const contractAddress = await TestERC1155.getContractAddress(contractName);
-    return {
-        opType: OperationType.CHECK,
-        checkType: CheckOperationType.ERC1155,
-        chainId: 31337n,
-        contractAddress,
-        params: encodeERC1155Params({ threshold, tokenId }),
-    };
-}
-export async function erc20CheckOp(contractName, threshold) {
-    const contractAddress = await TestERC20.getContractAddress(contractName);
-    return {
-        opType: OperationType.CHECK,
-        checkType: CheckOperationType.ERC20,
-        chainId: 31337n,
-        contractAddress,
-        params: encodeThresholdParams({ threshold }),
-    };
-}
-export async function mockCrossChainCheckOp(contractName, id) {
-    const contractAddress = await TestCrossChainEntitlement.getContractAddress(contractName);
-    return {
-        opType: OperationType.CHECK,
-        checkType: CheckOperationType.ISENTITLED,
-        chainId: 31337n,
-        contractAddress,
-        params: TestCrossChainEntitlement.encodeIdParameter(id),
-    };
-}
 export const twoEth = BigInt(2e18);
 export const oneEth = BigInt(1e18);
 export const threeEth = BigInt(3e18);
 export const oneHalfEth = BigInt(5e17);
-export function ethBalanceCheckOp(threshold) {
-    return {
-        opType: OperationType.CHECK,
-        checkType: CheckOperationType.ETH_BALANCE,
-        chainId: 31337n,
-        contractAddress: ethers.constants.AddressZero,
-        params: encodeThresholdParams({ threshold }),
-    };
-}
-/**
- * makeUniqueSpaceStreamId - space stream ids are derived from the contract
- * in tests without entitlements there are no contracts, so we use a random id
- */
-export const makeUniqueSpaceStreamId = () => {
-    return makeSpaceStreamId(genId(40));
+export const makeUniqueGDMStreamId = () => {
+    return makeUniqueGDMChannelStreamId();
 };
 /**
  *
@@ -205,9 +147,6 @@ export async function setupWalletsAndContexts() {
         bobProvider.fundWallet(),
         carolProvider.fundWallet(),
     ]);
-    const bobSpaceDapp = createSpaceDapp(bobProvider, baseConfig.chainConfig);
-    const aliceSpaceDapp = createSpaceDapp(aliceProvider, baseConfig.chainConfig);
-    const carolSpaceDapp = createSpaceDapp(carolProvider, baseConfig.chainConfig);
     // create a user
     const [alice, bob, carol] = await Promise.all([
         makeTestClient({
@@ -234,9 +173,6 @@ export async function setupWalletsAndContexts() {
         aliceProvider,
         bobProvider,
         carolProvider,
-        aliceSpaceDapp,
-        bobSpaceDapp,
-        carolSpaceDapp,
     };
 }
 class DonePromise {
@@ -318,355 +254,7 @@ export const lastEventFiltered = (events, f) => {
     });
     return ret;
 };
-// createSpaceAndDefaultChannel creates a space and default channel for a given
-// client, on the spaceDapp and the stream node. It creates a user stream, joins
-// the user to the space, and starts syncing the client.
-export async function createSpaceAndDefaultChannel(client, spaceDapp, wallet, name, membership) {
-    const transaction = await createVersionedSpaceFromMembership(client, spaceDapp, wallet, name, membership);
-    const receipt = await transaction.wait();
-    expect(receipt.status).toEqual(1);
-    const spaceAddress = spaceDapp.getSpaceAddress(receipt, wallet.address);
-    expect(spaceAddress).toBeDefined();
-    const spaceId = makeSpaceStreamId(spaceAddress);
-    const channelId = makeDefaultChannelStreamId(spaceAddress);
-    await client.initializeUser({ spaceId });
-    client.startSync();
-    const userStreamId = makeUserStreamId(client.userId);
-    const userStreamView = client.stream(userStreamId).view;
-    expect(userStreamView).toBeDefined();
-    const returnVal = await client.createSpace(spaceId);
-    expect(returnVal.streamId).toEqual(spaceId);
-    await waitFor(() => expect(userStreamView.userContent.isMember(spaceId, MembershipOp.SO_JOIN), `waitFor ${spaceId} in ${userStreamId}`).toBe(true));
-    const channelReturnVal = await client.createChannel(spaceId, 'general', `${name} general channel properties`, channelId);
-    expect(channelReturnVal.streamId).toEqual(channelId);
-    await waitFor(() => expect(userStreamView.userContent.isMember(channelId, MembershipOp.SO_JOIN), `waitFor ${channelId} in ${userStreamId}`).toBe(true));
-    return {
-        spaceId,
-        defaultChannelId: channelId,
-        userStreamView,
-    };
-}
 export const DefaultFreeAllocation = 1000;
-export async function createVersionedSpaceFromMembership(client, spaceDapp, wallet, name, membership) {
-    if (useLegacySpaces()) {
-        if (isLegacyMembershipType(membership)) {
-            return await spaceDapp.createLegacySpace({
-                spaceName: `${name}-space`,
-                uri: `${name}-space-metadata`,
-                channelName: 'general',
-                membership,
-            }, wallet);
-        }
-        else {
-            // Convert space params to legacy space params
-            const legacyMembership = {
-                settings: membership.settings,
-                permissions: membership.permissions,
-                requirements: {
-                    everyone: membership.requirements.everyone,
-                    users: membership.requirements.users,
-                    syncEntitlements: membership.requirements.syncEntitlements,
-                    ruleData: convertRuleDataV2ToV1(decodeRuleDataV2(membership.requirements.ruleData)),
-                },
-            };
-            return await spaceDapp.createLegacySpace({
-                spaceName: `${name}-space`,
-                uri: `${name}-space-metadata`,
-                channelName: 'general',
-                membership: legacyMembership,
-            }, wallet);
-        }
-    }
-    else {
-        if (isLegacyMembershipType(membership)) {
-            // Convert legacy space params to current space params
-            membership = {
-                settings: membership.settings,
-                permissions: membership.permissions,
-                requirements: {
-                    everyone: membership.requirements.everyone,
-                    users: [],
-                    syncEntitlements: false,
-                    ruleData: encodeRuleDataV2(convertRuleDataV1ToV2(membership.requirements.ruleData)),
-                },
-            };
-        }
-        return await spaceDapp.createSpace({
-            spaceName: `${name}-space`,
-            uri: `${name}-space-metadata`,
-            channelName: 'general',
-            membership,
-        }, wallet);
-    }
-}
-// createVersionedSpace accepts either legacy or current space creation parameters and will
-// fall backto the legacy space creation endpoint on the spaceDapp if the appropriate flag is set.
-// If a user does not pass in a legacy space creation parameter, the function will not use
-// the legacy space creation endpoint, because the updated parameters are not backwards
-// compatible - we don't attempt conversion here.
-export async function createVersionedSpace(spaceDapp, createSpaceParams, signer) {
-    if (useLegacySpaces() && isCreateLegacySpaceParams(createSpaceParams)) {
-        return await spaceDapp.createLegacySpace(createSpaceParams, signer);
-    }
-    else {
-        if (isCreateLegacySpaceParams(createSpaceParams)) {
-            // Convert legacy space params to current space params
-            createSpaceParams = {
-                spaceName: createSpaceParams.spaceName,
-                uri: createSpaceParams.uri,
-                channelName: createSpaceParams.channelName,
-                membership: {
-                    settings: createSpaceParams.membership.settings,
-                    permissions: createSpaceParams.membership.permissions,
-                    requirements: {
-                        everyone: createSpaceParams.membership.requirements.everyone,
-                        users: [],
-                        syncEntitlements: false,
-                        ruleData: encodeRuleDataV2(convertRuleDataV1ToV2(createSpaceParams.membership.requirements
-                            .ruleData)),
-                    },
-                },
-            };
-        }
-        return await spaceDapp.createSpace(createSpaceParams, signer);
-    }
-}
-// createUserStreamAndSyncClient creates a user stream for a given client that
-// uses a newly created space as the hint for the user stream, since the stream
-// node will not allow the creation of a user stream without a space id.
-//
-// If the membership info is a legacy membership struct and the legacy space flag
-// is set, the function will create a legacy space. Otherwise, it will convert the
-// legacy membership struct to a current membership struct if needed and use the
-// latest space creation endpoint.
-export async function createUserStreamAndSyncClient(client, spaceDapp, name, membershipInfo, wallet) {
-    let createSpaceParams;
-    if (isLegacyMembershipType(membershipInfo)) {
-        createSpaceParams = {
-            spaceName: `${name}-space`,
-            uri: `${name}-space-metadata`,
-            channelName: 'general',
-            membership: membershipInfo,
-        };
-    }
-    else {
-        createSpaceParams = {
-            spaceName: `${name}-space`,
-            uri: `${name}-space-metadata`,
-            channelName: 'general',
-            membership: membershipInfo,
-        };
-    }
-    const transaction = await createVersionedSpace(spaceDapp, createSpaceParams, wallet);
-    const receipt = await transaction.wait();
-    expect(receipt.status).toEqual(1);
-    const spaceAddress = spaceDapp.getSpaceAddress(receipt, wallet.address);
-    expect(spaceAddress).toBeDefined();
-    const spaceId = makeSpaceStreamId(spaceAddress);
-    await client.initializeUser({ spaceId });
-}
-export async function expectUserCanJoin(spaceId, channelId, name, client, spaceDapp, address, wallet) {
-    const joinStart = Date.now();
-    // Check that the local evaluation of the user's entitlements for joining the space
-    // passes.
-    const entitledWallet = await spaceDapp.getEntitledWalletForJoiningSpace(spaceId, address, getXchainConfigForTesting());
-    expect(entitledWallet).toBeDefined();
-    const { issued } = await spaceDapp.joinSpace(spaceId, address, wallet);
-    expect(issued).toBe(true);
-    log(`${name} joined space ${spaceId}`, Date.now() - joinStart);
-    await client.initializeUser({ spaceId });
-    client.startSync();
-    await waitFor(() => expect(client.streams.syncState).toBe(SyncState.Syncing));
-    await expect(client.joinStream(spaceId)).resolves.not.toThrow();
-    await expect(client.joinStream(channelId)).resolves.not.toThrow();
-    const userStreamView = client.stream(client.userStreamId).view;
-    await waitFor(() => {
-        expect(userStreamView.userContent.isMember(spaceId, MembershipOp.SO_JOIN), `waitFor ${spaceId} in ${client.userStreamId}`).toBe(true);
-        expect(userStreamView.userContent.isMember(channelId, MembershipOp.SO_JOIN), `waitFor ${channelId} in ${client.userStreamId}`).toBe(true);
-    });
-}
-export async function everyoneMembershipStruct(spaceDapp, client) {
-    const { fixedPricingModuleAddress, freeAllocation, price } = await getFreeSpacePricingSetup(spaceDapp);
-    return {
-        settings: {
-            name: 'Everyone',
-            symbol: 'MEMBER',
-            price,
-            maxSupply: 1000,
-            duration: 0,
-            currency: ETH_ADDRESS,
-            feeRecipient: client.userId,
-            freeAllocation,
-            pricingModule: fixedPricingModuleAddress,
-        },
-        permissions: [Permission.Read, Permission.Write],
-        requirements: {
-            everyone: true,
-            users: [],
-            ruleData: NoopRuleData,
-            syncEntitlements: false,
-        },
-    };
-}
-// should start charging after the first member joins
-export async function zeroPriceWithLimitedAllocationMembershipStruct(spaceDapp, client, opts) {
-    const { fixedPricingModuleAddress, price } = await getFreeSpacePricingSetup(spaceDapp);
-    const { freeAllocation } = opts;
-    const settings = {
-        settings: {
-            name: 'Everyone',
-            symbol: 'MEMBER',
-            price,
-            maxSupply: 1000,
-            duration: 0,
-            currency: ETH_ADDRESS,
-            feeRecipient: client.userId,
-            freeAllocation,
-            pricingModule: fixedPricingModuleAddress,
-        },
-        permissions: [Permission.Read, Permission.Write],
-        requirements: {
-            everyone: true,
-            users: [],
-            ruleData: NoopRuleData,
-            syncEntitlements: false,
-        },
-    };
-    return settings;
-}
-// should start charing for the first member
-export async function dynamicMembershipStruct(spaceDapp, client) {
-    const dynamicPricingModule = await getDynamicPricingModule(spaceDapp);
-    expect(dynamicPricingModule).toBeDefined();
-    return {
-        settings: {
-            name: 'Everyone',
-            symbol: 'MEMBER',
-            price: 0,
-            maxSupply: 1000,
-            duration: 0,
-            currency: ETH_ADDRESS,
-            feeRecipient: client.userId,
-            freeAllocation: 0,
-            pricingModule: dynamicPricingModule.module,
-        },
-        permissions: [Permission.Read, Permission.Write],
-        requirements: {
-            everyone: true,
-            users: [],
-            ruleData: NoopRuleData,
-            syncEntitlements: false,
-        },
-    };
-}
-// should start charging after the first member joins
-export async function fixedPriceMembershipStruct(spaceDapp, client, opts = { price: 1 }) {
-    const fixedPricingModule = await getFixedPricingModule(spaceDapp);
-    expect(fixedPricingModule).toBeDefined();
-    const { price } = opts;
-    const settings = {
-        settings: {
-            name: 'Everyone',
-            symbol: 'MEMBER',
-            price: ethers.utils.parseEther(price.toString()),
-            maxSupply: 1000,
-            duration: 0,
-            currency: ETH_ADDRESS,
-            feeRecipient: client.userId,
-            freeAllocation: 0,
-            pricingModule: fixedPricingModule.module,
-        },
-        permissions: [Permission.Read, Permission.Write],
-        requirements: {
-            everyone: true,
-            users: [],
-            ruleData: NoopRuleData,
-            syncEntitlements: false,
-        },
-    };
-    return settings;
-}
-export async function getFreeSpacePricingSetup(spaceDapp) {
-    const fixedPricingModule = await getFixedPricingModule(spaceDapp);
-    expect(fixedPricingModule).toBeDefined();
-    return {
-        price: 0,
-        fixedPricingModuleAddress: fixedPricingModule.module,
-        freeAllocation: DefaultFreeAllocation,
-    };
-}
-export function twoNftRuleData(nft1Address, nft2Address, logOpType = LogicalOperationType.AND) {
-    const leftOperation = {
-        opType: OperationType.CHECK,
-        checkType: CheckOperationType.ERC721,
-        chainId: 31337n,
-        contractAddress: nft1Address,
-        params: encodeThresholdParams({ threshold: 1n }),
-    };
-    const rightOperation = {
-        opType: OperationType.CHECK,
-        checkType: CheckOperationType.ERC721,
-        chainId: 31337n,
-        contractAddress: nft2Address,
-        params: encodeThresholdParams({ threshold: 1n }),
-    };
-    const root = {
-        opType: OperationType.LOGICAL,
-        logicalType: logOpType,
-        leftOperation,
-        rightOperation,
-    };
-    return treeToRuleData(root);
-}
-export async function unlinkCaller(rootSpaceDapp, rootWallet, caller) {
-    const walletLink = rootSpaceDapp.getWalletLink();
-    let txn;
-    try {
-        txn = await walletLink.removeCallerLink(caller);
-    }
-    catch (err) {
-        const parsedError = walletLink.parseError(err);
-        log('linkWallets error', parsedError);
-    }
-    expect(txn).toBeDefined();
-    const receipt = await txn?.wait();
-    expect(receipt.status).toEqual(1);
-    const linkedWallets = await walletLink.getLinkedWallets(rootWallet.address);
-    expect(linkedWallets).not.toContain(caller.address);
-}
-export async function unlinkWallet(rootSpaceDapp, rootWallet, linkedWallet) {
-    const walletLink = rootSpaceDapp.getWalletLink();
-    let txn;
-    try {
-        txn = await walletLink.removeLink(rootWallet, linkedWallet.address);
-    }
-    catch (err) {
-        const parsedError = walletLink.parseError(err);
-        log('linkWallets error', parsedError);
-    }
-    expect(txn).toBeDefined();
-    const receipt = await txn?.wait();
-    expect(receipt.status).toEqual(1);
-    const linkedWallets = await walletLink.getLinkedWallets(rootWallet.address);
-    expect(linkedWallets).not.toContain(linkedWallet.address);
-}
-// Hint: pass in the wallets attached to the providers.
-export async function linkWallets(rootSpaceDapp, rootWallet, linkedWallet) {
-    const walletLink = rootSpaceDapp.getWalletLink();
-    let txn;
-    try {
-        txn = await walletLink.linkWalletToRootKey(rootWallet, linkedWallet);
-    }
-    catch (err) {
-        const parsedError = walletLink.parseError(err);
-        log('linkWallets error', parsedError);
-    }
-    expect(txn).toBeDefined();
-    const receipt = await txn?.wait();
-    expect(receipt.status).toEqual(1);
-    const linkedWallets = await walletLink.getLinkedWallets(rootWallet.address);
-    expect(linkedWallets).toContain(linkedWallet.address);
-}
 /// wait for a value, return the value if it is defined, otherwise throw an error or return undefined. false is a valid value.
 export function waitForValue(callback, options = { timeoutMS: 10000 }) {
     const tmpError = new Error('tmp');
@@ -800,7 +388,7 @@ export async function waitForSyncStreamsMessage(syncStreams, message) {
             if (stream) {
                 const env = await unpackStreamEnvelopes(stream, undefined);
                 for (const e of env) {
-                    if (e.event.payload.case === 'channelPayload') {
+                    if (e.event.payload.case === 'gdmChannelPayload') {
                         const p = e.event.payload.value.content;
                         if (p.case === 'message' && p.value.ciphertext === message) {
                             return true;
@@ -841,78 +429,6 @@ export function isValidEthAddress(address) {
     const ethAddressRegex = /^(0x)?[0-9a-fA-F]{40}$/;
     return ethAddressRegex.test(address);
 }
-export function getNftRuleData(testNftAddress) {
-    return createExternalNFTStruct([testNftAddress]);
-}
-// createRole creates a role on the spaceDapp with the given parameters, using the legacy endpoint
-// if the USE_LEGACY_SPACES environment variable is set and converting the ruleData into the correct
-// format as necessary. Be aware, though, that the legacy endpoint does not support erc1155 checks.
-export async function createRole(spaceDapp, provider, spaceId, roleName, permissions, users, ruleData, signer) {
-    let txn = undefined;
-    let error = undefined;
-    if (useLegacySpaces()) {
-        try {
-            if (!isRuleDataV1(ruleData)) {
-                ruleData = convertRuleDataV2ToV1(ruleData);
-            }
-            txn = await spaceDapp.legacyCreateRole(spaceId, roleName, permissions, users, ruleData, signer);
-        }
-        catch (err) {
-            error = spaceDapp.parseSpaceError(spaceId, err);
-            return { roleId: undefined, error };
-        }
-    }
-    else {
-        if (isRuleDataV1(ruleData)) {
-            ruleData = convertRuleDataV1ToV2(ruleData);
-        }
-        try {
-            txn = await spaceDapp.createRole(spaceId, roleName, permissions, users, ruleData, signer);
-        }
-        catch (err) {
-            error = spaceDapp.parseSpaceError(spaceId, err);
-            return { roleId: undefined, error };
-        }
-    }
-    const { roleId, error: roleError } = await waitForRoleCreated(spaceDapp, spaceId, txn);
-    return { roleId, error: roleError };
-}
-export async function updateRole(spaceDapp, provider, params, signer) {
-    let txn = undefined;
-    let error = undefined;
-    if (useLegacySpaces()) {
-        throw new Error('updateRole is v2 only');
-    }
-    try {
-        txn = await spaceDapp.updateRole(params, signer);
-    }
-    catch (err) {
-        error = spaceDapp.parseSpaceError(params.spaceNetworkId, err);
-        return { error };
-    }
-    const receipt = await provider.waitForTransaction(txn.hash);
-    if (receipt.status === 0) {
-        return { error: new Error('Transaction failed') };
-    }
-    return { error: undefined };
-}
-export async function createChannel(spaceDapp, provider, spaceId, channelName, roleIds, signer) {
-    let txn = undefined;
-    let error = undefined;
-    const channelId = makeUniqueChannelStreamId(spaceId);
-    try {
-        txn = await spaceDapp.createChannel(spaceId, channelName, '', channelId, roleIds, signer);
-    }
-    catch (err) {
-        error = spaceDapp.parseSpaceError(spaceId, err);
-        return { channelId: undefined, error };
-    }
-    const receipt = await provider.waitForTransaction(txn.hash);
-    if (receipt.status === 0) {
-        return { channelId: undefined, error: new Error('Transaction failed') };
-    }
-    return { channelId, error: undefined };
-}
 // Type guard function based on field checks
 export function isEncryptedData(obj) {
     if (typeof obj !== 'object' || obj === null) {
@@ -926,128 +442,6 @@ export function isEncryptedData(obj) {
         (typeof data.checksum === 'string' || data.checksum === undefined) &&
         (typeof data.refEventId === 'string' || data.refEventId === undefined));
 }
-// Users need to be mapped from 'alice', 'bob', etc to their wallet addresses,
-// because the wallets are created within this helper method.
-export async function createTownWithRequirements(requirements) {
-    const { alice, bob, carol, aliceSpaceDapp, bobSpaceDapp, carolSpaceDapp, aliceProvider, bobProvider, carolProvider, alicesWallet, bobsWallet, carolsWallet, } = await setupWalletsAndContexts();
-    const { fixedPricingModuleAddress, freeAllocation, price } = await getFreeSpacePricingSetup(bobSpaceDapp);
-    const userNameToWallet = {
-        alice: alicesWallet.address,
-        bob: bobsWallet.address,
-        carol: carolsWallet.address,
-    };
-    requirements.users = requirements.users.map((user) => userNameToWallet[user]);
-    const membershipInfo = {
-        settings: {
-            name: 'Everyone',
-            symbol: 'MEMBER',
-            price,
-            maxSupply: 1000,
-            duration: requirements.duration ?? 0,
-            currency: ETH_ADDRESS,
-            feeRecipient: bob.userId,
-            freeAllocation,
-            pricingModule: fixedPricingModuleAddress,
-        },
-        permissions: [Permission.Read, Permission.Write],
-        requirements: {
-            everyone: requirements.everyone,
-            users: requirements.users,
-            ruleData: encodeRuleDataV2(requirements.ruleData),
-            syncEntitlements: false,
-        },
-    };
-    // This helper method validates that the owner can join the space and default channel.
-    const { spaceId, defaultChannelId: channelId, userStreamView: bobUserStreamView, } = await createSpaceAndDefaultChannel(bob, bobSpaceDapp, bobProvider.wallet, 'bobs', membershipInfo);
-    // Validate that owner passes entitlement check
-    const entitledWallet = await bobSpaceDapp.getEntitledWalletForJoiningSpace(spaceId, bobsWallet.address, getXchainConfigForTesting());
-    expect(entitledWallet).toBeDefined();
-    return {
-        alice,
-        bob,
-        carol,
-        aliceSpaceDapp,
-        bobSpaceDapp,
-        carolSpaceDapp,
-        aliceProvider,
-        bobProvider,
-        carolProvider,
-        alicesWallet,
-        bobsWallet,
-        carolsWallet,
-        spaceId,
-        channelId,
-        bobUserStreamView,
-    };
-}
-export async function expectUserCannotJoinSpace(spaceId, client, spaceDapp, address) {
-    // Check that the local evaluation of the user's entitlements for joining the space
-    // fails.
-    const entitledWallet = await spaceDapp.getEntitledWalletForJoiningSpace(spaceId, address, getXchainConfigForTesting());
-    expect(entitledWallet).toBeUndefined();
-    await expect(client.joinStream(spaceId)).rejects.toThrow(/PERMISSION_DENIED/);
-}
-// pass in users as 'alice', 'bob', 'carol' - b/c their wallets are created here
-export async function setupChannelWithCustomRole(userNames, ruleData, permissions = [Permission.Read]) {
-    const { alice, bob, carol, alicesWallet, bobsWallet, carolsWallet, aliceProvider, bobProvider, carolProvider, aliceSpaceDapp, bobSpaceDapp, carolSpaceDapp, } = await setupWalletsAndContexts();
-    const userNameToWallet = {
-        alice: alicesWallet.address,
-        bob: bobsWallet.address,
-        carol: carolsWallet.address,
-    };
-    const users = userNames.map((user) => userNameToWallet[user]);
-    const { spaceId, defaultChannelId } = await createSpaceAndDefaultChannel(bob, bobSpaceDapp, bobProvider.wallet, 'bob', await everyoneMembershipStruct(bobSpaceDapp, bob));
-    const { roleId, error: roleError } = await createRole(bobSpaceDapp, bobProvider, spaceId, 'gated role', permissions, users, ruleData, bobProvider.wallet);
-    expect(roleError).toBeUndefined();
-    log('roleId', roleId);
-    // Create a channel gated by the above role in the space contract.
-    const { channelId, error: channelError } = await createChannel(bobSpaceDapp, bobProvider, spaceId, 'custom-role-gated-channel', [roleId.valueOf()], bobProvider.wallet);
-    expect(channelError).toBeUndefined();
-    log('channelId', channelId);
-    // Then, establish a stream for the channel on the river node.
-    const { streamId: channelStreamId } = await bob.createChannel(spaceId, 'nft-gated-channel', 'talk about nfts here', channelId);
-    expect(channelStreamId).toEqual(channelId);
-    // As the space owner, Bob should always be able to join the channel regardless of the custom role.
-    await expect(bob.joinStream(channelId)).resolves.not.toThrow();
-    // Join alice to the town so she can attempt to join the role-gated channel.
-    // Alice should have no issue joining the space and default channel for an "everyone" town.
-    await expectUserCanJoin(spaceId, defaultChannelId, 'alice', alice, aliceSpaceDapp, alicesWallet.address, aliceProvider.wallet);
-    // Add carol to the space also so she can attempt to join role-gated channels.
-    await expectUserCanJoin(spaceId, defaultChannelId, 'carol', carol, carolSpaceDapp, carolsWallet.address, carolProvider.wallet);
-    return {
-        alice,
-        bob,
-        carol,
-        alicesWallet,
-        bobsWallet,
-        carolsWallet,
-        aliceProvider,
-        bobProvider,
-        carolProvider,
-        aliceSpaceDapp,
-        bobSpaceDapp,
-        carolSpaceDapp,
-        spaceId,
-        defaultChannelId,
-        channelId,
-        roleId,
-    };
-}
-export async function expectUserCanJoinChannel(client, spaceDapp, spaceId, channelId) {
-    // Space dapp should evaluate the user as entitled to the channel
-    await expect(spaceDapp.isEntitledToChannel(spaceId, channelId, client.userId, Permission.Read, getXchainConfigForTesting())).resolves.toBeTruthy();
-    // Stream node should allow the join
-    await expect(client.joinStream(channelId)).resolves.not.toThrow();
-    const userStreamView = (await client.waitForStream(makeUserStreamId(client.userId))).view;
-    // Wait for alice's user stream to have the join
-    await waitFor(() => expect(userStreamView.userContent.isMember(channelId, MembershipOp.SO_JOIN), `waitFor ${channelId} in ${client.userStreamId}`).toBe(true));
-}
-export async function expectUserCannotJoinChannel(client, spaceDapp, spaceId, channelId) {
-    // Space dapp should evaluate the user as not entitled to the channel
-    await expect(spaceDapp.isEntitledToChannel(spaceId, channelId, client.userId, Permission.Read, getXchainConfigForTesting())).resolves.toBeFalsy();
-    // Stream node should not allow the join
-    await expect(client.joinStream(channelId)).rejects.toThrow(/7:PERMISSION_DENIED/);
-}
 export const findMessageByText = (events, text) => {
     return events.find((event) => event.content?.kind === RiverTimelineEvent.ChannelMessage &&
         event.content.body === text);
@@ -1070,17 +464,4 @@ export function extractMemberBlockchainTransactions(client, channelId) {
         throw new Error('no stream found');
     return stream.view.getMembers().tokenTransfers;
 }
-export async function waitForRoleCreated(spaceDapp, spaceId, txn) {
-    const receipt = await spaceDapp.provider.waitForTransaction(txn.hash);
-    if (receipt.status === 0) {
-        return { roleId: undefined, error: new Error('Transaction failed') };
-    }
-    const parsedLogs = await spaceDapp.parseSpaceLogs(spaceId, receipt.logs);
-    const roleCreatedEvent = parsedLogs.find((log) => log?.name === 'RoleCreated');
-    if (!roleCreatedEvent) {
-        return { roleId: undefined, error: new Error('RoleCreated event not found') };
-    }
-    const roleId = roleCreatedEvent.args[1].toNumber();
-    return { roleId, error: undefined };
-}
 //# sourceMappingURL=testUtils.js.map