@ton-api/streaming/dist/index.d.ts

Realtime streaming SDK for tonapi.io

type BlockEvent = {
    workchain: -1 | 0;
    shard: string;
    seqno: number;
    root_hash: string;
    file_hash: string;
};

type AccountEvent = {
    account_id: string;
    lt: number;
    tx_hash: string;
    operation?: string;
};

type TraceEvent = {
    accounts: string[];
    hash: string;
};

type MempoolEvent = {
    boc: string;
    involved_accounts?: string[];
};

type JsonRpcRequest = {
    id: number | string;
    method: string;
    params: Record<string, unknown> | unknown[] | string;
};
type JsonRpcEvent = {
    method: string;
    params: Record<string, unknown> | unknown[];
};

type StreamSubscription<T extends JsonRpcEvent = JsonRpcEvent> = (event: T) => void;
interface StreamProvider {
    open(options?: {
        openingDeadlineMS?: number;
    }): Promise<void>;
    close(): Promise<void>;
    send(method: JsonRpcRequest['method'], params?: JsonRpcRequest['params']): Promise<void>;
    subscribe(subscription: StreamSubscription): () => void;
}

declare class WebsocketStreamProvider implements StreamProvider {
    private readonly url;
    private socket;
    private isClosed;
    private pendingRequests;
    private lastId;
    private subscriptions;
    constructor(url: string);
    open(options?: {
        openingDeadlineMS?: number;
    }): Promise<void>;
    close(): Promise<void>;
    send(method: string, params?: Record<string, unknown> | unknown[] | string): Promise<void>;
    subscribe(subscription: StreamSubscription): () => void;
    private errorsHandler;
    private messagesHandler;
}

declare abstract class Observer<T, E> {
    private readonly stream;
    protected subscribers: {
        callback: (event: E) => void;
        triggers: T[];
    }[];
    private socketSubscription;
    constructor(stream: StreamProvider);
    subscribe(triggers: T[] | T, callback: (event: E) => void): () => void;
    protected send(...args: Parameters<StreamProvider['send']>): Promise<void>;
    protected onEvent: (rpcEvent: JsonRpcEvent) => void;
    protected abstract afterSubscribed(subscriber: {
        triggers: T[];
        callback: (event: E) => void;
    }): void;
    protected abstract afterUnsubscribed(subscriber: {
        triggers: T[];
        callback: (event: E) => void;
    }): void;
    protected abstract tryTrigger(trigger: T, event: E): boolean;
    protected abstract extractEvent(rpcEvent: JsonRpcEvent): E | undefined;
}

declare class BlocksObserver extends Observer<number, BlockEvent> {
    subscribe(workchain: -1 | 0, callback: (event: BlockEvent) => void): () => void;
    protected afterSubscribed(subscriber: {
        triggers: number[];
    }): void;
    protected afterUnsubscribed({ triggers }: {
        triggers: number[];
    }): void;
    protected extractEvent(rpcEvent: JsonRpcEvent): BlockEvent | undefined;
    protected tryTrigger(trigger: number, event: BlockEvent): boolean;
}

type AccountsObserverTrigger = {
    account: string;
    operations?: string[];
};
declare class AccountsObserver extends Observer<AccountsObserverTrigger, AccountEvent> {
    protected afterSubscribed(subscriber: {
        triggers: AccountsObserverTrigger[];
    }): void;
    protected afterUnsubscribed({ triggers }: {
        triggers: AccountsObserverTrigger[];
    }): void;
    protected extractEvent(rpcEvent: JsonRpcEvent): AccountEvent | undefined;
    protected tryTrigger(trigger: AccountsObserverTrigger, event: AccountEvent): boolean;
}

declare class MempoolObserver extends Observer<string, MempoolEvent> {
    private needToRemoveAllSubscription;
    /**
     *
     * @param accounts list of accounts to watch (in raw-form) or a single account (in raw-form) or 'all' to watch all the accounts
     * @param callback
     */
    subscribe(accounts: string[] | string, callback: (event: MempoolEvent) => void): () => void;
    protected afterSubscribed(subscriber: {
        triggers: string[];
    }): void;
    protected afterUnsubscribed({ triggers }: {
        triggers: string[];
    }): void;
    protected extractEvent(rpcEvent: JsonRpcEvent): MempoolEvent | undefined;
    protected tryTrigger(trigger: string, event: MempoolEvent): boolean;
}

declare class TraceObserver extends Observer<string, TraceEvent> {
    protected afterSubscribed(subscriber: {
        triggers: string[];
    }): void;
    protected afterUnsubscribed({ triggers }: {
        triggers: string[];
    }): void;
    protected extractEvent(rpcEvent: JsonRpcEvent): TraceEvent | undefined;
    protected tryTrigger(trigger: string, event: TraceEvent): boolean;
}

export { type AccountEvent, AccountsObserver, type AccountsObserverTrigger, type BlockEvent, BlocksObserver, type MempoolEvent, MempoolObserver, type StreamProvider, type StreamSubscription, type TraceEvent, TraceObserver, WebsocketStreamProvider };