@towns-protocol/sdk
Version:
For more details, visit the following resources:
194 lines • 11.3 kB
TypeScript
import { EncryptedData, Envelope, StreamEvent, ChannelMessage, SyncStreamsResponse, PlainMessage, BlockchainTransaction_TokenTransfer } from '@towns-protocol/proto';
import { StreamStateView } from '../streamStateView';
import { Client, ClientOptions } from '../client';
import { ParsedEvent, StreamTimelineEvent } from '../types';
import { EntitlementsDelegate } from '../decryptionExtensions';
import { ethers } from 'ethers';
import { StreamRpcClient } from '../makeStreamRpcClient';
import { SignerContext } from '../signerContext';
import { Address, LocalhostWeb3Provider, IRuleEntitlementBase, Permission, LegacyMembershipStruct, MembershipStruct, LogicalOperationType, Operation, SpaceDapp, CreateSpaceParams, CreateLegacySpaceParams, SignerType, IRuleEntitlementV2Base, XchainConfig, UpdateRoleParams } from '@towns-protocol/web3';
import { type TimelineEvent } from '../views/models/timelineTypes';
import { RpcOptions } from '../rpcCommon';
import { MemberTokenTransfer } from '../streamStateView_Members';
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: SpaceDapp;
bobSpaceDapp: SpaceDapp;
carolSpaceDapp: SpaceDapp;
}>;
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: SpaceDapp, wallet: ethers.Wallet, name: string, membership: LegacyMembershipStruct | MembershipStruct): Promise<{
spaceId: string;
defaultChannelId: string;
userStreamView: StreamStateView;
}>;
export declare const DefaultFreeAllocation = 1000;
export declare function createVersionedSpaceFromMembership(client: Client, spaceDapp: SpaceDapp, wallet: ethers.Wallet, name: string, membership: LegacyMembershipStruct | MembershipStruct): Promise<ethers.ContractTransaction>;
export declare function createVersionedSpace(spaceDapp: SpaceDapp, createSpaceParams: CreateSpaceParams | CreateLegacySpaceParams, signer: SignerType): Promise<ethers.ContractTransaction>;
export declare function createUserStreamAndSyncClient(client: Client, spaceDapp: SpaceDapp, name: string, membershipInfo: LegacyMembershipStruct | MembershipStruct, wallet: ethers.Wallet): Promise<void>;
export declare function expectUserCanJoin(spaceId: string, channelId: string, name: string, client: Client, spaceDapp: SpaceDapp, address: string, wallet: ethers.Wallet): Promise<void>;
export declare function everyoneMembershipStruct(spaceDapp: SpaceDapp, client: Client): Promise<LegacyMembershipStruct>;
export declare function zeroPriceWithLimitedAllocationMembershipStruct(spaceDapp: SpaceDapp, client: Client, opts: {
freeAllocation: number;
}): Promise<LegacyMembershipStruct>;
export declare function dynamicMembershipStruct(spaceDapp: SpaceDapp, client: Client): Promise<LegacyMembershipStruct>;
export declare function fixedPriceMembershipStruct(spaceDapp: SpaceDapp, client: Client, opts?: {
price: number;
}): Promise<LegacyMembershipStruct>;
export declare function getFreeSpacePricingSetup(spaceDapp: SpaceDapp): 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: SpaceDapp, rootWallet: ethers.Wallet, caller: ethers.Wallet): Promise<void>;
export declare function unlinkWallet(rootSpaceDapp: SpaceDapp, rootWallet: ethers.Wallet, linkedWallet: ethers.Wallet): Promise<void>;
export declare function linkWallets(rootSpaceDapp: SpaceDapp, rootWallet: ethers.Wallet, linkedWallet: ethers.Wallet): Promise<void>;
export declare function waitForValue<T>(callback: () => T | undefined, options?: {
timeoutMS: number;
}): Promise<T>;
export declare function waitFor<T extends void | boolean>(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 getTimelineMessagePayload(event?: TimelineEvent): 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: SpaceDapp, 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: SpaceDapp, 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: SpaceDapp, 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;
duration?: number;
}): Promise<{
alice: TestClient;
bob: TestClient;
carol: TestClient;
aliceSpaceDapp: SpaceDapp;
bobSpaceDapp: SpaceDapp;
carolSpaceDapp: SpaceDapp;
aliceProvider: LocalhostWeb3Provider;
bobProvider: LocalhostWeb3Provider;
carolProvider: LocalhostWeb3Provider;
alicesWallet: ethers.Wallet;
bobsWallet: ethers.Wallet;
carolsWallet: ethers.Wallet;
spaceId: string;
channelId: string;
bobUserStreamView: StreamStateView;
}>;
export declare function expectUserCannotJoinSpace(spaceId: string, client: Client, spaceDapp: SpaceDapp, 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: SpaceDapp;
bobSpaceDapp: SpaceDapp;
carolSpaceDapp: SpaceDapp;
spaceId: string;
defaultChannelId: string;
channelId: string | undefined;
roleId: number | undefined;
}>;
export declare function expectUserCanJoinChannel(client: Client, spaceDapp: SpaceDapp, spaceId: string, channelId: string): Promise<void>;
export declare function expectUserCannotJoinChannel(client: Client, spaceDapp: SpaceDapp, 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): MemberTokenTransfer[];
export {};
//# sourceMappingURL=testUtils.d.ts.map