@lasersell/lasersell-sdk 0.1.0

package/dist/stream/client.d.ts

@@ -0,0 +1,144 @@
+import { type ClientMessage, type ServerMessage, type StrategyConfigMsg } from "./proto.js";
+export declare const STREAM_ENDPOINT = "wss://stream.lasersell.io/v1/ws";
+export declare const LOCAL_STREAM_ENDPOINT = "ws://localhost:8082/v1/ws";
+export interface StreamConfigure {
+    wallet_pubkeys: string[];
+    strategy: StrategyConfigMsg;
+    deadline_timeout_sec?: number;
+}
+export interface OptionalStrategyConfig {
+    target_profit_pct?: number;
+    stop_loss_pct?: number;
+}
+export interface StreamLanesOptions {
+    /**
+     * Maximum number of low-priority messages (currently `pnl_update`) to buffer.
+     *
+     * When full, the oldest low-priority message is dropped to keep the stream hot path responsive.
+     *
+     * Defaults to 1024.
+     */
+    lowPriorityCapacity?: number;
+}
+export declare function singleWalletStreamConfigure(walletPubkey: string, strategy: StrategyConfigMsg, deadlineTimeoutSec?: number): StreamConfigure;
+export declare function strategyConfigFromOptional(strategy?: OptionalStrategyConfig): StrategyConfigMsg;
+export declare function singleWalletStreamConfigureOptional(walletPubkey: string, strategy?: OptionalStrategyConfig, deadlineTimeoutSec?: number): StreamConfigure;
+export type PositionSelector = {
+    token_account: string;
+    position_id?: never;
+} | {
+    position_id: number;
+    token_account?: never;
+};
+export type PositionSelectorInput = PositionSelector | string | number | {
+    tokenAccount: string;
+} | {
+    positionId: number;
+} | {
+    token_account: string;
+} | {
+    position_id: number;
+};
+export type StreamClientErrorKind = "websocket" | "json" | "invalid_api_key_header" | "send_queue_closed" | "protocol";
+export declare class StreamClientError extends Error {
+    readonly kind: StreamClientErrorKind;
+    private constructor();
+    static websocket(cause: unknown): StreamClientError;
+    static json(cause: unknown): StreamClientError;
+    static invalidApiKeyHeader(cause: unknown): StreamClientError;
+    static sendQueueClosed(): StreamClientError;
+    static protocol(message: string): StreamClientError;
+}
+export declare class StreamClient {
+    private readonly apiKey;
+    private local;
+    private endpointOverride?;
+    constructor(apiKey: string);
+    withLocalMode(local: boolean): this;
+    withEndpoint(endpoint: string): this;
+    connect(configure: StreamConfigure): Promise<StreamConnection>;
+    connectLanes(configure: StreamConfigure, options?: StreamLanesOptions): Promise<StreamConnectionLanes>;
+    private endpoint;
+}
+export declare function validateStrategyAndDeadline(strategy: StrategyConfigMsg, deadlineTimeoutSec: number): void;
+export declare class StreamConnection {
+    private readonly worker;
+    constructor(worker: StreamConnectionWorker);
+    sender(): StreamSender;
+    split(): [StreamSender, StreamReceiver];
+    recv(): Promise<ServerMessage | null>;
+    close(): void;
+}
+export declare class StreamConnectionLanes {
+    private readonly worker;
+    constructor(worker: StreamConnectionWorker);
+    sender(): StreamSender;
+    highReceiver(): StreamHighReceiver;
+    lowReceiver(): StreamLowReceiver;
+    split(): [StreamSender, StreamHighReceiver, StreamLowReceiver];
+    close(): void;
+}
+export declare class StreamHighReceiver {
+    private readonly worker;
+    constructor(worker: StreamConnectionWorker);
+    recv(): Promise<ServerMessage | null>;
+    [Symbol.asyncIterator](): AsyncGenerator<ServerMessage, void, void>;
+}
+export declare class StreamLowReceiver {
+    private readonly worker;
+    constructor(worker: StreamConnectionWorker);
+    recv(): Promise<ServerMessage | null>;
+    [Symbol.asyncIterator](): AsyncGenerator<ServerMessage, void, void>;
+}
+export declare class StreamReceiver {
+    private readonly worker;
+    constructor(worker: StreamConnectionWorker);
+    recv(): Promise<ServerMessage | null>;
+    [Symbol.asyncIterator](): AsyncGenerator<ServerMessage, void, void>;
+}
+export declare class StreamSender {
+    private readonly worker;
+    constructor(worker: StreamConnectionWorker);
+    send(message: ClientMessage): void;
+    ping(client_time_ms: number): void;
+    updateStrategy(strategy: StrategyConfigMsg): void;
+    closePosition(selector: PositionSelectorInput): void;
+    closeById(positionId: number): void;
+    requestExitSignal(selector: PositionSelectorInput, slippage_bps?: number): void;
+    requestExitSignalById(positionId: number, slippage_bps?: number): void;
+}
+type InboundMode = "combined" | "lanes";
+interface StreamConnectionWorkerOptions {
+    inboundMode?: InboundMode;
+    lowPriorityCapacity?: number;
+}
+declare class StreamConnectionWorker {
+    private readonly endpoint;
+    private readonly apiKey;
+    private readonly configure;
+    private readonly inboundMode;
+    private readonly inboundCombined?;
+    private readonly inboundHigh?;
+    private readonly inboundLow?;
+    private readonly outbound;
+    private currentSocket;
+    private stopped;
+    private readonly readyPromise;
+    private readySettled;
+    private resolveReady;
+    private rejectReady;
+    constructor(endpoint: string, apiKey: string, configure: StreamConfigure, options?: StreamConnectionWorkerOptions);
+    waitReady(): Promise<void>;
+    enqueue(message: ClientMessage): void;
+    recv(): Promise<ServerMessage | null>;
+    recvHigh(): Promise<ServerMessage | null>;
+    recvLow(): Promise<ServerMessage | null>;
+    close(): void;
+    private run;
+    private runConnectedSession;
+    private handleFrame;
+    private setReadyError;
+    private pushInbound;
+    private closeInbound;
+}
+export {};