@river-build/sdk/dist/tests/testUtils.d.ts

For more details, visit the following resources:

import { EncryptedData, Envelope, StreamEvent, ChannelMessage, SyncStreamsResponse, PlainMessage, BlockchainTransaction_TokenTransfer } from '@river-build/proto';
import { IStreamStateView } from '../streamStateView';
import { Client, ClientOptions } from '../client';
import { ParsedEvent, StreamTimelineEvent } from '../types';
import { EntitlementsDelegate } from '@river-build/encryption';
import { ethers } from 'ethers';
import { StreamRpcClient } from '../makeStreamRpcClient';
import { SignerContext } from '../signerContext';
import { Address, LocalhostWeb3Provider, IRuleEntitlementBase, Permission, ISpaceDapp, LegacyMembershipStruct, MembershipStruct, LogicalOperationType, Operation, CreateSpaceParams, CreateLegacySpaceParams, SignerType, IRuleEntitlementV2Base, XchainConfig, UpdateRoleParams } from '@river-build/web3';
import { type TimelineEvent } from '../sync-agent/timeline/models/timeline-types';
import { RpcOptions } from '../rpcCommon';
export declare const makeTestRpcClient: (opts?: RpcOptions) => Promise<StreamRpcClient>;
export declare const makeEvent_test: (context: SignerContext, payload: PlainMessage<StreamEvent>['payload'], prevMiniblockHash?: Uint8Array) => Promise<Envelope>;
export declare const TEST_ENCRYPTED_MESSAGE_PROPS: PlainMessage<EncryptedData>;
export declare const getXchainConfigForTesting: () => XchainConfig;
export declare function erc1155CheckOp(contractName: string, tokenId: bigint, threshold: bigint): Promise<Operation>;
export declare function erc20CheckOp(contractName: string, threshold: bigint): Promise<Operation>;
export declare function mockCrossChainCheckOp(contractName: string, id: bigint): Promise<Operation>;
export declare const twoEth: bigint;
export declare const oneEth: bigint;
export declare const threeEth: bigint;
export declare const oneHalfEth: bigint;
export declare function ethBalanceCheckOp(threshold: bigint): Operation;
/**
 * makeUniqueSpaceStreamId - space stream ids are derived from the contract
 * in tests without entitlements there are no contracts, so we use a random id
 */
export declare const makeUniqueSpaceStreamId: () => string;
export type SignerContextWithWallet = SignerContext & {
    wallet: ethers.Wallet;
};
/**
 *
 * @returns a random user context
 * Done using a worker thread to avoid blocking the main thread
 */
export declare const makeRandomUserContext: () => Promise<SignerContextWithWallet>;
export declare const makeRandomUserAddress: () => Uint8Array;
export declare const makeUserContextFromWallet: (wallet: ethers.Wallet) => Promise<SignerContextWithWallet>;
export interface TestClient extends Client {
    wallet: ethers.Wallet;
    deviceId: string;
    signerContext: SignerContextWithWallet;
}
export interface TestClientOpts extends ClientOptions {
    context?: SignerContextWithWallet;
    entitlementsDelegate?: EntitlementsDelegate;
    deviceId?: string;
}
export declare const cloneTestClient: (client: TestClient) => Promise<TestClient>;
export declare const makeTestClient: (opts?: TestClientOpts) => Promise<TestClient>;
export declare function setupWalletsAndContexts(): Promise<{
    alice: TestClient;
    bob: TestClient;
    carol: TestClient;
    alicesWallet: ethers.Wallet;
    bobsWallet: ethers.Wallet;
    carolsWallet: ethers.Wallet;
    alicesContext: SignerContext & {
        wallet: ethers.Wallet;
    };
    bobsContext: SignerContext & {
        wallet: ethers.Wallet;
    };
    carolsContext: SignerContext & {
        wallet: ethers.Wallet;
    };
    aliceProvider: LocalhostWeb3Provider;
    bobProvider: LocalhostWeb3Provider;
    carolProvider: LocalhostWeb3Provider;
    aliceSpaceDapp: ISpaceDapp;
    bobSpaceDapp: ISpaceDapp;
    carolSpaceDapp: ISpaceDapp;
}>;
declare class DonePromise {
    promise: Promise<string>;
    resolve: (value: string) => void;
    reject: (reason: any) => void;
    constructor();
    done(): void;
    wait(): Promise<string>;
    expectToSucceed(): Promise<void>;
    expectToFail(): Promise<void>;
    run(fn: () => void): void;
    runAndDone(fn: () => void): void;
}
export declare const makeDonePromise: () => DonePromise;
export declare const sendFlush: (client: StreamRpcClient) => Promise<void>;
export declare function iterableWrapper<T>(iterable: AsyncIterable<T>): AsyncGenerator<T, void, unknown>;
export declare const lastEventFiltered: <T extends (a: ParsedEvent) => any>(events: ParsedEvent[], f: T) => ReturnType<T> | undefined;
export declare function createSpaceAndDefaultChannel(client: Client, spaceDapp: ISpaceDapp, wallet: ethers.Wallet, name: string, membership: LegacyMembershipStruct | MembershipStruct): Promise<{
    spaceId: string;
    defaultChannelId: string;
    userStreamView: IStreamStateView;
}>;
export declare const DefaultFreeAllocation = 1000;
export declare function createVersionedSpaceFromMembership(client: Client, spaceDapp: ISpaceDapp, wallet: ethers.Wallet, name: string, membership: LegacyMembershipStruct | MembershipStruct): Promise<ethers.ContractTransaction>;
export declare function createVersionedSpace(spaceDapp: ISpaceDapp, createSpaceParams: CreateSpaceParams | CreateLegacySpaceParams, signer: SignerType): Promise<ethers.ContractTransaction>;
export declare function createUserStreamAndSyncClient(client: Client, spaceDapp: ISpaceDapp, name: string, membershipInfo: LegacyMembershipStruct | MembershipStruct, wallet: ethers.Wallet): Promise<void>;
export declare function expectUserCanJoin(spaceId: string, channelId: string, name: string, client: Client, spaceDapp: ISpaceDapp, address: string, wallet: ethers.Wallet): Promise<void>;
export declare function everyoneMembershipStruct(spaceDapp: ISpaceDapp, client: Client): Promise<LegacyMembershipStruct>;
export declare function zeroPriceWithLimitedAllocationMembershipStruct(spaceDapp: ISpaceDapp, client: Client, opts: {
    freeAllocation: number;
}): Promise<LegacyMembershipStruct>;
export declare function dynamicMembershipStruct(spaceDapp: ISpaceDapp, client: Client): Promise<LegacyMembershipStruct>;
export declare function fixedPriceMembershipStruct(spaceDapp: ISpaceDapp, client: Client, opts?: {
    price: number;
}): Promise<LegacyMembershipStruct>;
export declare function getFreeSpacePricingSetup(spaceDapp: ISpaceDapp): Promise<{
    fixedPricingModuleAddress: string;
    freeAllocation: number;
    price: number;
}>;
export declare function twoNftRuleData(nft1Address: string, nft2Address: string, logOpType?: LogicalOperationType.AND | LogicalOperationType.OR): IRuleEntitlementV2Base.RuleDataV2Struct;
export declare function unlinkCaller(rootSpaceDapp: ISpaceDapp, rootWallet: ethers.Wallet, caller: ethers.Wallet): Promise<void>;
export declare function unlinkWallet(rootSpaceDapp: ISpaceDapp, rootWallet: ethers.Wallet, linkedWallet: ethers.Wallet): Promise<void>;
export declare function linkWallets(rootSpaceDapp: ISpaceDapp, rootWallet: ethers.Wallet, linkedWallet: ethers.Wallet): Promise<void>;
export declare function waitFor<T>(callback: (() => T) | (() => Promise<T>), options?: {
    timeoutMS: number;
}): Promise<T>;
export declare function waitForSyncStreams(syncStreams: AsyncIterable<SyncStreamsResponse>, matcher: (res: SyncStreamsResponse) => Promise<boolean>): Promise<SyncStreamsResponse>;
export declare function waitForSyncStreamsMessage(syncStreams: AsyncIterable<SyncStreamsResponse>, message: string): Promise<SyncStreamsResponse>;
export declare function getChannelMessagePayload(event?: ChannelMessage): string | undefined;
export declare function createEventDecryptedPromise(client: Client, expectedMessageText: string): Promise<string>;
export declare function isValidEthAddress(address: string): boolean;
export declare function getNftRuleData(testNftAddress: Address): IRuleEntitlementV2Base.RuleDataV2Struct;
export interface CreateRoleContext {
    roleId: number | undefined;
    error: Error | undefined;
}
export declare function createRole(spaceDapp: ISpaceDapp, provider: ethers.providers.Provider, spaceId: string, roleName: string, permissions: Permission[], users: string[], ruleData: IRuleEntitlementBase.RuleDataStruct | IRuleEntitlementV2Base.RuleDataV2Struct, signer: ethers.Signer): Promise<CreateRoleContext>;
export interface UpdateRoleContext {
    error: Error | undefined;
}
export declare function updateRole(spaceDapp: ISpaceDapp, provider: ethers.providers.Provider, params: UpdateRoleParams, signer: ethers.Signer): Promise<UpdateRoleContext>;
export interface CreateChannelContext {
    channelId: string | undefined;
    error: Error | undefined;
}
export declare function createChannel(spaceDapp: ISpaceDapp, provider: ethers.providers.Provider, spaceId: string, channelName: string, roleIds: number[], signer: ethers.Signer): Promise<CreateChannelContext>;
export declare function isEncryptedData(obj: unknown): obj is EncryptedData;
export declare function createTownWithRequirements(requirements: {
    everyone: boolean;
    users: string[];
    ruleData: IRuleEntitlementV2Base.RuleDataV2Struct;
}): Promise<{
    alice: TestClient;
    bob: TestClient;
    carol: TestClient;
    aliceSpaceDapp: ISpaceDapp;
    bobSpaceDapp: ISpaceDapp;
    carolSpaceDapp: ISpaceDapp;
    aliceProvider: LocalhostWeb3Provider;
    bobProvider: LocalhostWeb3Provider;
    carolProvider: LocalhostWeb3Provider;
    alicesWallet: ethers.Wallet;
    bobsWallet: ethers.Wallet;
    carolsWallet: ethers.Wallet;
    spaceId: string;
    channelId: string;
    bobUserStreamView: IStreamStateView;
}>;
export declare function expectUserCannotJoinSpace(spaceId: string, client: Client, spaceDapp: ISpaceDapp, address: string): Promise<void>;
export declare function setupChannelWithCustomRole(userNames: string[], ruleData: IRuleEntitlementV2Base.RuleDataV2Struct, permissions?: Permission[]): Promise<{
    alice: TestClient;
    bob: TestClient;
    carol: TestClient;
    alicesWallet: ethers.Wallet;
    bobsWallet: ethers.Wallet;
    carolsWallet: ethers.Wallet;
    aliceProvider: LocalhostWeb3Provider;
    bobProvider: LocalhostWeb3Provider;
    carolProvider: LocalhostWeb3Provider;
    aliceSpaceDapp: ISpaceDapp;
    bobSpaceDapp: ISpaceDapp;
    carolSpaceDapp: ISpaceDapp;
    spaceId: string;
    defaultChannelId: string;
    channelId: string | undefined;
    roleId: number | undefined;
}>;
export declare function expectUserCanJoinChannel(client: Client, spaceDapp: ISpaceDapp, spaceId: string, channelId: string): Promise<void>;
export declare function expectUserCannotJoinChannel(client: Client, spaceDapp: ISpaceDapp, spaceId: string, channelId: string): Promise<void>;
export declare const findMessageByText: (events: TimelineEvent[], text: string) => TimelineEvent | undefined;
export declare function extractBlockchainTransactionTransferEvents(timeline: StreamTimelineEvent[]): BlockchainTransaction_TokenTransfer[];
export declare function extractMemberBlockchainTransactions(client: Client, channelId: string): BlockchainTransaction_TokenTransfer[];
export {};
//# sourceMappingURL=testUtils.d.ts.map