@towns-labs/sdk 2.0.1

package/dist/tests/testUtils.js

@@ -0,0 +1,1086 @@
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+/* 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 { Client } from '../client';
+import { townsEnv } from '../townsEnv';
+import { genId, makeSpaceStreamId, makeDefaultChannelStreamId, makeUniqueChannelStreamId, makeUserStreamId, userIdFromAddress, } from '../id';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { bin_fromHexString, check, dlog, publicKeyToAddress } from '@towns-labs/utils';
+import { ethers } from 'ethers';
+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 { 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();
+    log('initTestUrls, RIVER_TEST_CONNECT=', config, 'testUrls=', urls);
+    return { testUrls: urls.split(','), refreshNodeUrl: undefined };
+};
+let curTestUrl = -1;
+const getNextTestUrl = async () => {
+    const { testUrls, refreshNodeUrl } = await initTestUrls();
+    if (testUrls.length === 1) {
+        log('getNextTestUrl, url=', testUrls[0]);
+        return { urls: testUrls[0], refreshNodeUrl };
+    }
+    else if (testUrls.length > 1) {
+        if (curTestUrl < 0) {
+            const seed = expect.getState()?.currentTestName;
+            if (seed === undefined) {
+                curTestUrl = Math.floor(Math.random() * testUrls.length);
+                log('getNextTestUrl, setting to random, index=', curTestUrl);
+            }
+            else {
+                curTestUrl =
+                    seed
+                        .split('')
+                        .map((v) => v.charCodeAt(0))
+                        .reduce((a, v) => ((a + ((a << 7) + (a << 3))) ^ v) & 0xffff) %
+                        testUrls.length;
+                log('getNextTestUrl, setting based on test name=', seed, ' index=', curTestUrl);
+            }
+        }
+        curTestUrl = (curTestUrl + 1) % testUrls.length;
+        log('getNextTestUrl, url=', testUrls[curTestUrl], 'index=', curTestUrl);
+        return { urls: testUrls[curTestUrl], refreshNodeUrl };
+    }
+    else {
+        throw new Error('no test urls');
+    }
+};
+export const makeTestRpcClient = async (opts) => {
+    const { urls: url, refreshNodeUrl } = await getNextTestUrl();
+    return makeStreamRpcClient(url, refreshNodeUrl, opts);
+};
+export const makeEvent_test = async (context, payload, prevMiniblockHash) => {
+    return _impl_makeEvent_impl_(context, payload, prevMiniblockHash);
+};
+export const TEST_ENCRYPTED_MESSAGE_PROPS = {
+    sessionId: '',
+    sessionIdBytes: new Uint8Array(0),
+    ciphertext: '',
+    algorithm: '',
+    senderKey: '',
+    ciphertextBytes: new Uint8Array(0),
+    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));
+};
+/**
+ *
+ * @returns a random user context
+ * Done using a worker thread to avoid blocking the main thread
+ */
+export const makeRandomUserContext = async () => {
+    const wallet = ethers.Wallet.createRandom();
+    log('makeRandomUserContext', wallet.address);
+    return await makeUserContextFromWallet(wallet);
+};
+export const makeRandomUserAddress = () => {
+    return publicKeyToAddress(secp256k1.getPublicKey(secp256k1.utils.randomPrivateKey(), false));
+};
+export const makeUserContextFromWallet = async (wallet) => {
+    const userPrimaryWallet = wallet;
+    const delegateWallet = ethers.Wallet.createRandom();
+    const creatorAddress = publicKeyToAddress(bin_fromHexString(userPrimaryWallet.publicKey));
+    log('makeRandomUserContext', userIdFromAddress(creatorAddress));
+    return { ...(await makeSignerContext(userPrimaryWallet, delegateWallet, { days: 1 })), wallet };
+};
+export const cloneTestClient = async (client) => {
+    return makeTestClient({
+        ...client.opts,
+        context: {
+            ...client.signerContext,
+            wallet: client.wallet,
+        },
+        deviceId: client.deviceId,
+    });
+};
+export const makeTestClient = async (opts) => {
+    const context = opts?.context ?? (await makeRandomUserContext());
+    const deviceId = opts?.deviceId ? `-${opts.deviceId}` : `-${genId(5)}`;
+    const userId = userIdFromAddress(context.creatorAddress);
+    const dbName = `database-${userId}${deviceId}`;
+    const persistenceDbName = `persistence-${userId}${deviceId}`;
+    const appAddress = opts?.appAddress;
+    // create a new client with store(s)
+    const cryptoStore = RiverDbManager.getCryptoDb(userId, dbName);
+    const rpcClient = await makeTestRpcClient();
+    const client = new Client(context, appAddress, rpcClient, cryptoStore, {
+        ...opts,
+        persistenceStoreName: persistenceDbName,
+    });
+    client.wallet = context.wallet;
+    client.deviceId = deviceId;
+    return client;
+};
+export async function setupWalletsAndContexts() {
+    const baseConfig = townsEnv().makeBaseChainConfig();
+    const [alicesWallet, bobsWallet, carolsWallet] = [
+        ethers.Wallet.createRandom(),
+        ethers.Wallet.createRandom(),
+        ethers.Wallet.createRandom(),
+    ];
+    const [alicesContext, bobsContext, carolsContext] = await Promise.all([
+        makeUserContextFromWallet(alicesWallet),
+        makeUserContextFromWallet(bobsWallet),
+        makeUserContextFromWallet(carolsWallet),
+    ]);
+    const aliceProvider = new LocalhostWeb3Provider(baseConfig.rpcUrl, alicesWallet);
+    const bobProvider = new LocalhostWeb3Provider(baseConfig.rpcUrl, bobsWallet);
+    const carolProvider = new LocalhostWeb3Provider(baseConfig.rpcUrl, carolsWallet);
+    await Promise.all([
+        aliceProvider.fundWallet(),
+        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({
+            context: alicesContext,
+            deviceId: 'alice',
+        }),
+        makeTestClient({
+            context: bobsContext,
+        }),
+        makeTestClient({
+            context: carolsContext,
+        }),
+    ]);
+    return {
+        alice,
+        bob,
+        carol,
+        alicesWallet,
+        bobsWallet,
+        carolsWallet,
+        alicesContext,
+        bobsContext,
+        carolsContext,
+        aliceProvider,
+        bobProvider,
+        carolProvider,
+        aliceSpaceDapp,
+        bobSpaceDapp,
+        carolSpaceDapp,
+    };
+}
+class DonePromise {
+    promise;
+    // @ts-ignore: Promise body is executed immediately, so vars are assigned before constructor returns
+    resolve;
+    // @ts-ignore: Promise body is executed immediately, so vars are assigned before constructor returns
+    reject;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+    done() {
+        this.resolve('done');
+    }
+    async wait() {
+        return this.promise;
+    }
+    async expectToSucceed() {
+        await expect(this.promise).resolves.toBe('done');
+    }
+    async expectToFail() {
+        await expect(this.promise).rejects.toThrow();
+    }
+    run(fn) {
+        try {
+            fn();
+        }
+        catch (err) {
+            this.reject(err);
+        }
+    }
+    runAndDone(fn) {
+        try {
+            fn();
+            this.done();
+        }
+        catch (err) {
+            this.reject(err);
+        }
+    }
+}
+export const makeDonePromise = () => {
+    return new DonePromise();
+};
+export const sendFlush = async (client) => {
+    const r = await client.info({ debug: ['flush_cache'] });
+    check(r.graffiti === 'cache flushed');
+};
+export async function* iterableWrapper(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    while (true) {
+        const result = await iterator.next();
+        if (typeof result === 'string') {
+            return;
+        }
+        yield result.value;
+    }
+}
+// For example, use like this:
+//
+//    joinPayload = lastEventFiltered(
+//        unpackStreamEnvelopes(userResponse.stream!),
+//        getUserPayload_Membership,
+//    )
+//
+// to get user membership payload from a last event containing it, or undefined if not found.
+export const lastEventFiltered = (events, f) => {
+    let ret = undefined;
+    forEachRight(events, (v) => {
+        const r = f(v);
+        if (r !== undefined) {
+            ret = r;
+            return false;
+        }
+        return true;
+    });
+    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');
+    const timeoutContext = new Error('waitFor timed out after ' + options.timeoutMS.toString() + 'ms\n' + tmpError.stack);
+    return new Promise((resolve, reject) => {
+        const timeoutMS = options.timeoutMS;
+        const pollIntervalMS = Math.min(timeoutMS / 2, 100);
+        let lastError = undefined;
+        const intervalId = setInterval(checkCallback, pollIntervalMS);
+        const timeoutId = setInterval(onTimeout, timeoutMS);
+        function onDone(result) {
+            clearInterval(intervalId);
+            clearInterval(timeoutId);
+            if (result) {
+                resolve(result);
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                reject(lastError);
+            }
+        }
+        function onTimeout() {
+            lastError = lastError ?? timeoutContext;
+            onDone(undefined);
+        }
+        function checkCallback() {
+            try {
+                const result = callback();
+                if (result !== undefined) {
+                    // if result is truthy, resolve
+                    onDone(result);
+                }
+                // otherwise let the polling continue
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+    });
+}
+/// wait for the callback to not throw an error or return anything other than false (undefined is a valid value)
+/// usage (preferred):
+/// await waitFor(() => {
+///     expect(true).toBe(true)
+///     expect(myCounter.count).toBe(10)
+/// })
+/// usage (acceptable):
+/// await waitFor(() => {
+///     return myCounter.count > 9 // not preferred, but valid
+/// })
+/// usage (alternate):
+/// const myValidValue = await waitFor(async () => {
+///     const result = await myPromiseThatReturnsValueOrUndefinedOrError()
+///     return result
+/// })
+export function waitFor(callback, options = { timeoutMS: 10000 }) {
+    const tmpError = new Error('tmp');
+    const timeoutContext = new Error('waitFor timed out after ' + options.timeoutMS.toString() + 'ms\n' + tmpError.stack);
+    return new Promise((resolve, reject) => {
+        const timeoutMS = options.timeoutMS;
+        const pollIntervalMS = Math.min(timeoutMS / 2, 100);
+        let timedOut = false;
+        let lastError = undefined;
+        let promiseStatus = 'none';
+        const intervalId = setInterval(checkCallback, pollIntervalMS);
+        const timeoutId = setInterval(onTimeout, timeoutMS);
+        function onDone(result) {
+            clearInterval(intervalId);
+            clearInterval(timeoutId);
+            if (result) {
+                resolve(result);
+            }
+            else if (result === undefined && promiseStatus === 'resolved') {
+                resolve(undefined);
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                reject(lastError);
+            }
+        }
+        function onTimeout() {
+            lastError = lastError ?? timeoutContext;
+            timedOut = true;
+            onDone();
+        }
+        function checkCallback() {
+            if (promiseStatus === 'pending')
+                return;
+            try {
+                const result = callback();
+                if (result && result instanceof Promise) {
+                    promiseStatus = 'pending';
+                    result.then((res) => {
+                        if (!timedOut) {
+                            promiseStatus = 'resolved';
+                            onDone(res);
+                        }
+                    }, (err) => {
+                        promiseStatus = 'rejected';
+                        lastError = err;
+                    });
+                }
+                else {
+                    // explicitly check for false, most of these will return void
+                    if (result !== false) {
+                        promiseStatus = 'resolved';
+                        // if result is truthy, resolve
+                        onDone(result);
+                    }
+                    // otherwise let the polling continue
+                }
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+    });
+}
+export async function waitForSyncStreams(syncStreams, matcher) {
+    for await (const res of iterableWrapper(syncStreams)) {
+        if (await matcher(res)) {
+            return res;
+        }
+    }
+    throw new Error('waitFor: timeout');
+}
+export async function waitForSyncStreamsMessage(syncStreams, message) {
+    return waitForSyncStreams(syncStreams, async (res) => {
+        if (res.syncOp === SyncOp.SYNC_UPDATE) {
+            const stream = res.stream;
+            if (stream) {
+                const env = await unpackStreamEnvelopes(stream, undefined);
+                for (const e of env) {
+                    if (e.event.payload.case === 'channelPayload') {
+                        const p = e.event.payload.value.content;
+                        if (p.case === 'message' && p.value.ciphertext === message) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    });
+}
+export function getChannelMessagePayload(event) {
+    if (event?.payload?.case === 'post') {
+        if (event.payload.value.content.case === 'text') {
+            return event.payload.value.content.value?.body;
+        }
+    }
+    return undefined;
+}
+export function getTimelineMessagePayload(event) {
+    if (event?.content?.kind === RiverTimelineEvent.ChannelMessage) {
+        return event.content.body;
+    }
+    return undefined;
+}
+export function createEventDecryptedPromise(client, expectedMessageText) {
+    const recipientReceivesMessageWithoutError = makeDonePromise();
+    client.on('eventDecrypted', (streamId, contentKind, event) => {
+        recipientReceivesMessageWithoutError.runAndDone(() => {
+            expect(event.content).toBeDefined();
+            check(event.content?.kind === RiverTimelineEvent.ChannelMessage);
+            expect(event.content.body).toEqual(expectedMessageText);
+        });
+    });
+    return recipientReceivesMessageWithoutError.promise;
+}
+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) {
+        return false;
+    }
+    const data = obj;
+    return (typeof data.ciphertext === 'string' &&
+        typeof data.algorithm === 'string' &&
+        typeof data.senderKey === 'string' &&
+        typeof data.sessionId === 'string' &&
+        (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);
+};
+export function extractBlockchainTransactionTransferEvents(timeline) {
+    return timeline
+        .map((e) => {
+        if (e.remoteEvent?.event.payload.case === 'userPayload' &&
+            e.remoteEvent?.event.payload.value.content.case === 'blockchainTransaction' &&
+            e.remoteEvent?.event.payload.value.content.value.content.case === 'tokenTransfer') {
+            return e.remoteEvent?.event.payload.value.content.value.content.value;
+        }
+        return undefined;
+    })
+        .filter(isDefined);
+}
+export function extractMemberBlockchainTransactions(client, channelId) {
+    const stream = client.streams.get(channelId);
+    if (!stream)
+        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