@towns-protocol/sdk/dist/sync-agent/river-connection/riverConnection.d.ts

For more details, visit the following resources:

import { RiverRegistry, SpaceDapp } from '@towns-protocol/web3';
import { RiverChain } from './models/riverChain';
import { Identifiable, Store } from '../../store/store';
import { CryptoStore, type EncryptionDeviceInitOpts } from '@towns-protocol/encryption';
import { EntitlementsDelegate } from '../../decryptionExtensions';
import { Client, ClientOptions } from '../../client';
import { SignerContext } from '../../signerContext';
import { PersistedObservable } from '../../observable/persistedObservable';
import { TransactionalClient } from './models/transactionalClient';
import { Observable } from '../../observable/observable';
import { AuthStatus } from './models/authStatus';
import { RetryParams } from '../../rpcInterceptors';
import { Stream } from '../../stream';
export interface ClientParams {
    signerContext: SignerContext;
    cryptoStore: CryptoStore;
    entitlementsDelegate: EntitlementsDelegate;
    opts?: ClientOptions;
    encryptionDevice?: EncryptionDeviceInitOpts;
    onTokenExpired?: () => void;
    rpcRetryParams?: RetryParams;
}
export type OnStoppedFn = () => void;
export type onClientStartedFn = (client: Client) => OnStoppedFn;
export interface RiverConnectionModel extends Identifiable {
    id: '0';
    userExists: boolean;
}
export declare class RiverConnection extends PersistedObservable<RiverConnectionModel> {
    spaceDapp: SpaceDapp;
    riverRegistryDapp: RiverRegistry;
    clientParams: ClientParams;
    client?: TransactionalClient;
    riverChain: RiverChain;
    authStatus: Observable<AuthStatus>;
    loginError?: Error;
    private logger;
    private clientQueue;
    private views;
    private onStoppedFns;
    newUserMetadata?: {
        spaceId: Uint8Array | string;
    };
    private loginPromise?;
    constructor(store: Store, spaceDapp: SpaceDapp, riverRegistryDapp: RiverRegistry, clientParams: ClientParams);
    protected onLoaded(): void;
    get userId(): string;
    start(): Promise<void>;
    stop(): Promise<void>;
    call<T>(fn: (client: Client) => Promise<T>): Promise<T>;
    withStream(streamId: string): {
        call: <T>(fn: (client: Client, stream: Stream) => Promise<T>) => Promise<T>;
    };
    callWithStream<T>(streamId: string, fn: (client: Client, stream: Stream) => Promise<T>): Promise<T>;
    registerView(viewFn: onClientStartedFn): void;
    private createStreamsClient;
    login(newUserMetadata?: {
        spaceId: Uint8Array | string;
    }): Promise<void>;
    private loginWithRetries;
}
//# sourceMappingURL=riverConnection.d.ts.map