@acta-markets/ts-sdk 0.0.1-beta

package/dist/ws/client.js

@@ -0,0 +1,857 @@
+/** Acta WebSocket client (rfq-server). */
+import { buildSignedQuoteMessage, buildAcceptQuoteMessage } from "./flows";
+import { assertWsU64Safe } from "./wirePolicy";
+function formatServerError(error) {
+    if (error.type === "generic") {
+        return `${error.data.code}: ${error.data.message}`;
+    }
+    if ("data" in error) {
+        const payload = typeof error.data === "string" ? error.data : JSON.stringify(error.data);
+        return `${error.type}: ${payload}`;
+    }
+    return error.type;
+}
+class TypedEventEmitter {
+    listeners = new Map();
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = ((...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        });
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        set?.delete(listener);
+        if (set && set.size === 0)
+            this.listeners.delete(event);
+        return this;
+    }
+    removeAllListeners(event) {
+        if (event === undefined) {
+            this.listeners.clear();
+        }
+        else {
+            this.listeners.delete(event);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set || set.size === 0)
+            return false;
+        for (const listener of Array.from(set)) {
+            listener(...args);
+        }
+        return true;
+    }
+}
+const WS_CONNECTING = 0;
+const WS_OPEN = 1;
+function defaultSocketFactory() {
+    const WsCtor = globalThis.WebSocket;
+    if (!WsCtor) {
+        throw new Error("No global WebSocket available. Provide `makeSocket` (e.g. using the `ws` package in Node).");
+    }
+    return (url) => new WsCtor(url);
+}
+function getCloseInfo(ev) {
+    if (!ev || typeof ev !== "object")
+        return {};
+    const rec = ev;
+    return {
+        code: typeof rec.code === "number" ? rec.code : undefined,
+        reason: typeof rec.reason === "string" ? rec.reason : undefined,
+    };
+}
+export class ActaWsClient extends TypedEventEmitter {
+    ws = null;
+    options;
+    authProvider = null;
+    authRequested = false;
+    startAuthSent = false;
+    connectionState = "disconnected";
+    sessionId = null;
+    helloSent = false;
+    welcomeReceived = false;
+    pendingMessages = [];
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    pingTimer = null;
+    shouldReconnect = true;
+    subscribedChannels = new Set(["rfqs"]);
+    subscribedMarkets = new Set();
+    hasMarketScope = false;
+    state = {
+        stats: null,
+        activeRfqs: new Map(),
+        myActiveRfqs: new Map(),
+        positions: new Map(),
+        recentTrades: [],
+        markets: new Map(),
+    };
+    constructor(options) {
+        super();
+        this.options = {
+            protocolVersion: "1.0.0",
+            features: [],
+            autoReconnect: true,
+            reconnectDelay: 1000,
+            maxReconnectDelay: 30_000,
+            reconnectJitterRatio: 0.2,
+            pingInterval: 30_000,
+            maxPendingMessages: 100,
+            pendingMessagesOverflowPolicy: "drop_oldest",
+            debug: false,
+            makeSocket: options.makeSocket ?? defaultSocketFactory(),
+            ...options,
+        };
+        this.options.maxPendingMessages = Math.max(0, Math.floor(this.options.maxPendingMessages));
+        this.options.reconnectJitterRatio = Math.min(1, Math.max(0, this.options.reconnectJitterRatio));
+        this.shouldReconnect = this.options.autoReconnect;
+    }
+    connectAnonymous() {
+        this.authProvider = null;
+        this.authRequested = false;
+        this.shouldReconnect = this.options.autoReconnect;
+        this.doConnect();
+    }
+    connect(authProvider) {
+        this.authProvider = authProvider;
+        this.authRequested = false;
+        this.shouldReconnect = this.options.autoReconnect;
+        this.doConnect();
+    }
+    connectAndAuthenticate(authProvider) {
+        this.authProvider = authProvider;
+        this.authRequested = true;
+        this.shouldReconnect = this.options.autoReconnect;
+        if (this.ws?.readyState === WS_OPEN) {
+            if (this.welcomeReceived && !this.startAuthSent) {
+                void this.sendStartAuth().catch((err) => {
+                    this.emit("error", err);
+                    this.setConnectionState("error");
+                });
+            }
+            return;
+        }
+        this.doConnect();
+    }
+    async authenticate(authProvider) {
+        this.authProvider = authProvider;
+        this.authRequested = true;
+        if (this.ws?.readyState === WS_OPEN) {
+            if (this.welcomeReceived && !this.startAuthSent) {
+                await this.sendStartAuth();
+            }
+            return;
+        }
+        if (!this.ws) {
+            throw new Error("WebSocket is not connected");
+        }
+    }
+    disconnect() {
+        this.shouldReconnect = false;
+        this.cleanup();
+    }
+    getConnectionState() {
+        return this.connectionState;
+    }
+    isAuthenticated() {
+        return this.connectionState === "authenticated";
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    async createRfq(request) {
+        this.ensureAuthenticated();
+        this.send({
+            type: "RfqRequest",
+            data: {
+                market: request.market,
+                position_type: request.position_type,
+                strike: request.strike,
+                quantity: request.quantity,
+                timeout_seconds: request.timeoutSeconds ?? 30,
+                client_request_id: request.clientRequestId,
+            },
+        });
+    }
+    async acceptQuote(rfqId, maker, orderIdHex) {
+        this.ensureAuthenticated();
+        this.send({
+            type: "AcceptQuote",
+            data: { rfq_id: rfqId, maker, order_id: orderIdHex },
+        });
+    }
+    /**
+     * Convenience: build and send `AcceptQuote` from a raw 32-byte `orderId`.
+     */
+    async acceptQuoteByOrderId(args) {
+        const msg = buildAcceptQuoteMessage({
+            rfqId: args.rfqId,
+            maker: args.maker,
+            orderId: args.orderId,
+        });
+        return await this.acceptQuote(args.rfqId, args.maker, msg.order_id);
+    }
+    /**
+     * Submit a partially-signed sponsored transaction back to the server.
+     *
+     * `txBase64` must be a base64-encoded `VersionedTransaction` (v0) signed by the taker.
+     */
+    async submitSignedSponsoredTx(args) {
+        this.ensureAuthenticated();
+        this.send({
+            type: "SubmitSignedSponsoredTx",
+            data: { order_id: args.orderIdHex, tx_base64: args.txBase64 },
+        });
+    }
+    getPositions() {
+        this.ensureAuthenticated();
+        this.send({ type: "GetPositions" });
+    }
+    getMarkets() {
+        this.send({ type: "GetMarkets" });
+    }
+    getMarketDescriptors(args) {
+        const data = {
+            active_only: args?.active_only ?? true,
+        };
+        this.send({ type: "GetMarketDescriptors", data });
+    }
+    getExpiries(args) {
+        this.send({
+            type: "GetExpiries",
+            data: {
+                underlying_mint: args?.underlying_mint,
+                quote_mint: args?.quote_mint,
+                is_put: args?.is_put ?? null,
+            },
+        });
+    }
+    getTokens(args) {
+        const data = {
+            active_only: args?.active_only ?? true,
+        };
+        this.send({ type: "GetTokens", data });
+    }
+    getMyActiveRfqs() {
+        this.ensureAuthenticated();
+        this.send({ type: "GetMyActiveRfqs" });
+    }
+    getActiveRfqs() {
+        this.send({ type: "GetActiveRfqs" });
+    }
+    getOrderStatus(orderIdHex) {
+        this.ensureAuthenticated();
+        this.send({ type: "GetOrderStatus", data: { order_id: orderIdHex } });
+    }
+    cancelRfq(rfqId) {
+        this.ensureAuthenticated();
+        this.send({ type: "CancelRfq", data: { rfq_id: rfqId } });
+    }
+    submitQuote(quote) {
+        this.ensureAuthenticated();
+        this.send({ type: "Quote", data: quote });
+    }
+    /**
+     * Convenience: sign 32-byte `orderId` and send `Quote`.
+     *
+     * Maker constructs the full on-chain order (incl. nonce), computes `orderId`,
+     * signs it, and sends the signature + orderId over WS.
+     */
+    async submitQuoteSigned(args) {
+        assertWsU64Safe(args.strike, "strike");
+        assertWsU64Safe(args.price, "price");
+        assertWsU64Safe(args.validUntil, "validUntil");
+        assertWsU64Safe(args.nonce, "nonce");
+        const quote = await buildSignedQuoteMessage({
+            rfqId: args.rfqId,
+            strike: args.strike,
+            price: args.price,
+            validUntil: args.validUntil,
+            nonce: args.nonce,
+            orderId: args.orderId,
+            makerSigner: args.makerSigner,
+        });
+        this.submitQuote(quote);
+    }
+    cancelQuote(rfqId) {
+        this.ensureAuthenticated();
+        this.send({ type: "CancelQuote", data: { rfq_id: rfqId } });
+    }
+    subscribe(channels, markets) {
+        this.ensureAuthenticated();
+        for (const c of channels)
+            this.subscribedChannels.add(c);
+        if (markets) {
+            this.hasMarketScope = true;
+            this.subscribedMarkets = new Set(markets);
+        }
+        this.send({
+            type: "Subscribe",
+            data: this.hasMarketScope
+                ? { channels, markets: Array.from(this.subscribedMarkets) }
+                : { channels },
+        });
+    }
+    unsubscribe(channels) {
+        this.ensureAuthenticated();
+        for (const c of channels)
+            this.subscribedChannels.delete(c);
+        this.send({
+            type: "Unsubscribe",
+            data: { channels },
+        });
+    }
+    ping() {
+        if (this.ws?.readyState === WS_OPEN) {
+            this.send({ type: "Ping" });
+        }
+    }
+    doConnect() {
+        if (this.ws) {
+            this.cleanup();
+        }
+        this.setConnectionState("connecting");
+        this.emit("connecting");
+        const endpoint = this.options.role === "maker" ? "/ws/maker" : "/ws/taker";
+        const url = `${this.options.url}${endpoint}`;
+        this.log(`Connecting to ${url}`);
+        const ws = this.options.makeSocket(url);
+        this.ws = ws;
+        this.helloSent = false;
+        this.welcomeReceived = false;
+        this.startAuthSent = false;
+        this.pendingMessages = [];
+        ws.onopen = () => {
+            this.log("WebSocket connected");
+            this.reconnectAttempts = 0;
+            this.sendHello();
+            this.emit("connected");
+            this.startPingInterval();
+        };
+        ws.onmessage = (event) => {
+            try {
+                const parsed = JSON.parse(event.data);
+                this.handleMessage(parsed);
+            }
+            catch (err) {
+                this.log("Failed to parse message:", err);
+            }
+        };
+        ws.onclose = (ev) => {
+            const info = getCloseInfo(ev);
+            const code = typeof info.code === "number" ? info.code : 1000;
+            const reason = typeof info.reason === "string" ? info.reason : "";
+            this.log(`WebSocket closed: ${code} ${reason}`);
+            this.cleanup();
+            this.emit("disconnected", code, reason);
+            if (this.shouldReconnect) {
+                this.scheduleReconnect();
+            }
+        };
+        ws.onerror = (ev) => {
+            this.log("WebSocket error:", ev);
+            this.emit("error", new Error("WebSocket error"));
+            if (this.shouldReconnect) {
+                this.cleanup();
+                this.scheduleReconnect();
+            }
+        };
+    }
+    handleMessage(message) {
+        this.log("Received:", message.type);
+        this.emit("message", message);
+        switch (message.type) {
+            case "Welcome":
+                this.welcomeReceived = true;
+                this.emit("welcome", message.data);
+                this.flushPendingMessages();
+                if (this.authRequested && this.authProvider && !this.startAuthSent) {
+                    void this.sendStartAuth().catch((err) => {
+                        this.emit("error", err);
+                        this.setConnectionState("error");
+                    });
+                }
+                break;
+            case "VersionMismatch":
+                this.emit("versionMismatch", message.data);
+                this.stopAutoReconnect();
+                this.setConnectionState("error");
+                if (this.ws &&
+                    (this.ws.readyState === WS_OPEN ||
+                        this.ws.readyState === WS_CONNECTING)) {
+                    try {
+                        this.ws.close(1002, "version_mismatch");
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                break;
+            case "AuthRequest":
+                void this.handleAuthRequest(message.data.challenge);
+                break;
+            case "AuthSuccess":
+                this.handleAuthSuccess(message.data.session_id);
+                break;
+            case "AuthError":
+                this.handleAuthError(message.data.reason);
+                break;
+            case "Snapshot":
+                this.handleSnapshot(message.data);
+                break;
+            case "Positions":
+                this.handlePositions(message.data.positions ?? []);
+                break;
+            case "Markets":
+                this.handleMarkets(message.data.markets ?? []);
+                break;
+            case "MarketDescriptors":
+                this.emit("marketDescriptors", message.data.markets ?? []);
+                break;
+            case "Expiries":
+                this.emit("expiries", message.data.expiries_ts ?? []);
+                break;
+            case "Tokens":
+                this.emit("tokens", {
+                    underlyings: message.data.underlyings ?? [],
+                    quotesByUnderlying: message.data.quotes_by_underlying ?? {},
+                });
+                break;
+            case "Subscriptions":
+                this.emit("subscriptions", message.data);
+                break;
+            case "ActiveRfqs":
+                this.state.activeRfqs.clear();
+                for (const rfq of message.data.rfqs) {
+                    this.state.activeRfqs.set(rfq.rfq_id, rfq);
+                }
+                this.emit("activeRfqs", message.data.rfqs);
+                break;
+            case "MyActiveRfqs":
+                this.handleMyActiveRfqs(message.data);
+                break;
+            case "OrderStatus":
+                this.handleOrderStatus(message.data);
+                break;
+            case "StatsUpdate":
+                this.handleStatsUpdate(message.data.stats);
+                break;
+            case "RfqBroadcast":
+                // Keep local RFQ state reasonably fresh even without a new snapshot.
+                if (!this.state.activeRfqs.has(message.data.rfq_id)) {
+                    this.state.activeRfqs.set(message.data.rfq_id, {
+                        rfq_id: message.data.rfq_id,
+                        market: message.data.market.market_pda,
+                        position_type: message.data.position_type,
+                        strike: message.data.strike,
+                        quantity: message.data.quantity,
+                        expires_at: message.data.expires_at,
+                        quotes_count: 0,
+                        best_price: null,
+                        order_options: message.data.order_options,
+                    });
+                }
+                this.emit("rfqBroadcast", message.data);
+                break;
+            case "RfqCreated":
+                this.emit("rfqCreated", message.data);
+                break;
+            case "RfqClosed":
+                this.state.activeRfqs.delete(message.data.rfq_id);
+                this.emit("rfqClosed", message.data);
+                break;
+            case "QuoteReceived":
+                {
+                    const rfq = this.state.activeRfqs.get(message.data.rfq_id);
+                    if (rfq) {
+                        const nextCount = rfq.quotes_count + 1;
+                        const nextBest = rfq.best_price === null
+                            ? message.data.price
+                            : Math.max(rfq.best_price, message.data.price);
+                        this.state.activeRfqs.set(message.data.rfq_id, {
+                            ...rfq,
+                            quotes_count: nextCount,
+                            best_price: nextBest,
+                        });
+                    }
+                    this.emit("quoteReceived", message.data);
+                }
+                break;
+            case "QuotesUpdate":
+                {
+                    const rfq = this.state.activeRfqs.get(message.data.rfq_id);
+                    if (rfq) {
+                        const prices = message.data.quotes.map((q) => q.price);
+                        const nextBest = prices.length === 0 ? null : Math.max(...prices);
+                        this.state.activeRfqs.set(message.data.rfq_id, {
+                            ...rfq,
+                            quotes_count: message.data.quotes.length,
+                            best_price: nextBest,
+                        });
+                    }
+                    this.emit("quotesUpdate", message.data);
+                }
+                break;
+            case "QuoteAcknowledged":
+                this.emit("quoteAcknowledged", message.data);
+                break;
+            case "QuoteBestStatus":
+                this.emit("quoteBestStatus", message.data);
+                break;
+            case "QuoteOutbid":
+                this.emit("quoteOutbid", message.data);
+                break;
+            case "QuoteRefreshRequested":
+                this.emit("quoteRefreshRequested", message.data);
+                break;
+            case "QuoteSelected":
+                this.emit("quoteSelected", message.data);
+                break;
+            case "QuoteFilled":
+                this.emit("quoteFilled", message.data);
+                break;
+            case "QuoteCancelled":
+                this.emit("quoteCancelled", message.data);
+                break;
+            case "RfqAvailableAgain":
+                this.emit("rfqAvailableAgain", message.data);
+                break;
+            case "QuoteExpired":
+                this.emit("quoteExpired", message.data);
+                break;
+            case "IndicativePrices":
+                this.emit("indicativePrices", message.data);
+                break;
+            case "IndicativePricesRequest":
+                this.emit("indicativePricesRequest", message.data);
+                break;
+            case "OrderAccepted":
+                this.emit("orderAccepted", message.data.order_id);
+                break;
+            case "SponsoredTxToSign":
+                this.emit("sponsoredTxToSign", message.data.order_id, message.data.tx_base64, message.data.signature_deadline);
+                break;
+            case "OrderSubmitted":
+                this.emit("orderSubmitted", message.data.order_id, message.data.tx_signature);
+                break;
+            case "OrderConfirmed":
+                this.emit("orderConfirmed", message.data.order_id, message.data.position_pda);
+                break;
+            case "OrderFailed":
+                this.emit("orderFailed", message.data.order_id, message.data.reason);
+                break;
+            case "TradeExecuted":
+                this.handleTradeExecuted(message.data);
+                break;
+            case "PositionUpdated":
+                this.handlePositionUpdated(message.data);
+                break;
+            case "MarketCreated":
+                this.state.markets.set(message.data.pda, message.data);
+                this.emit("marketCreated", message.data);
+                break;
+            case "MarketFinalized":
+                this.emit("marketFinalized", message.data.market_pda, message.data.settlement_price);
+                break;
+            case "ChainEvent":
+                this.handleChainEvent(message.data);
+                break;
+            case "Pong":
+                break;
+            case "Error":
+                this.emit("error", new Error(formatServerError(message.data)));
+                break;
+        }
+    }
+    /** Taker-only: request current indicative prices for a market + position_type. */
+    getIndicativePrices(req) {
+        this.send({
+            type: "GetIndicativePrices",
+            data: req,
+        });
+    }
+    /** Maker-only: respond to an indicative request (unsigned, non-binding). */
+    sendIndicativePricesResponse(resp) {
+        this.ensureAuthenticated();
+        this.send({ type: "IndicativePricesResponse", data: resp });
+    }
+    async handleAuthRequest(challenge) {
+        this.setConnectionState("authenticating");
+        if (!this.authProvider) {
+            this.emit("error", new Error("No auth provider configured"));
+            return;
+        }
+        try {
+            const [pubkey, signature] = await Promise.all([
+                this.authProvider.getPublicKey(),
+                this.authProvider.signChallenge(challenge),
+            ]);
+            this.send({
+                type: "AuthChallenge",
+                data: { challenge, signature, pubkey },
+            });
+        }
+        catch (err) {
+            this.emit("error", err);
+            this.setConnectionState("error");
+        }
+    }
+    async sendStartAuth() {
+        if (!this.authProvider)
+            throw new Error("No auth provider configured");
+        this.startAuthSent = true;
+        const pubkey = await this.authProvider.getPublicKey();
+        this.send({ type: "StartAuth", data: { pubkey } });
+    }
+    sendHello() {
+        const hello = {
+            protocol_version: this.options.protocolVersion,
+            features: this.options.features ?? [],
+            client_name: this.options.clientName,
+            client_version: this.options.clientVersion,
+        };
+        this.send({ type: "Hello", data: hello });
+    }
+    flushPendingMessages() {
+        if (!this.welcomeReceived || this.pendingMessages.length === 0)
+            return;
+        const pending = this.pendingMessages;
+        this.pendingMessages = [];
+        for (const msg of pending) {
+            this.send(msg);
+        }
+    }
+    handleAuthSuccess(sessionId) {
+        this.sessionId = sessionId;
+        this.setConnectionState("authenticated");
+        this.emit("authenticated", sessionId);
+        if (this.subscribedChannels.size > 0) {
+            const channels = Array.from(this.subscribedChannels);
+            const data = this.hasMarketScope
+                ? { channels, markets: Array.from(this.subscribedMarkets) }
+                : { channels };
+            this.send({ type: "Subscribe", data });
+        }
+    }
+    handleAuthError(reason) {
+        this.setConnectionState("error");
+        this.emit("error", new Error(`Authentication failed: ${reason}`));
+    }
+    handleSnapshot(snapshot) {
+        this.state.stats = snapshot.stats;
+        this.state.activeRfqs.clear();
+        for (const rfq of snapshot.active_rfqs) {
+            this.state.activeRfqs.set(rfq.rfq_id, rfq);
+        }
+        this.state.myActiveRfqs.clear();
+        this.state.positions.clear();
+        for (const position of snapshot.positions ?? []) {
+            this.state.positions.set(position.pda, position);
+        }
+        this.state.recentTrades = snapshot.recent_trades ?? [];
+        this.state.markets.clear();
+        for (const market of snapshot.markets) {
+            this.state.markets.set(market.pda, market);
+        }
+        this.emit("snapshot", snapshot);
+    }
+    handleMyActiveRfqs(msg) {
+        this.state.myActiveRfqs.clear();
+        for (const rfq of msg.rfqs) {
+            this.state.myActiveRfqs.set(rfq.rfq_id, rfq);
+        }
+        this.emit("myActiveRfqs", msg);
+    }
+    handleOrderStatus(msg) {
+        this.emit("orderStatus", msg);
+    }
+    handlePositions(positions) {
+        this.state.positions.clear();
+        for (const position of positions) {
+            this.state.positions.set(position.pda, position);
+        }
+        this.emit("positions", positions);
+    }
+    handleMarkets(markets) {
+        this.state.markets.clear();
+        for (const market of markets) {
+            this.state.markets.set(market.pda, market);
+        }
+        this.emit("markets", markets);
+    }
+    handleStatsUpdate(stats) {
+        this.state.stats = stats;
+        this.emit("statsUpdate", stats);
+    }
+    handleTradeExecuted(data) {
+        this.state.recentTrades.unshift(data.trade);
+        this.state.recentTrades = this.state.recentTrades.slice(0, 50);
+        const delta = data.stats_delta ?? null;
+        if (delta && this.state.stats) {
+            if (delta.volume_added)
+                this.state.stats.total_volume_24h += delta.volume_added;
+            if (delta.trades_added)
+                this.state.stats.total_trades_24h += delta.trades_added;
+            if (delta.price_added)
+                this.state.stats.total_price_24h += delta.price_added;
+        }
+        this.emit("tradeExecuted", data.trade, delta);
+    }
+    handlePositionUpdated(data) {
+        this.state.positions.set(data.position.pda, data.position);
+        this.emit("positionUpdated", data.position, data.update_type);
+    }
+    handleChainEvent(event) {
+        this.emit("chainEvent", event);
+        switch (event.event_type) {
+            case "PositionOpened":
+                this.emit("positionOpened", event);
+                break;
+            case "MakerRegistered":
+                this.emit("makerRegistered", event);
+                break;
+            case "MarketCreated":
+                this.emit("chainMarketCreated", event);
+                break;
+            case "MarketFinalized":
+                this.emit("chainMarketFinalized", event);
+                break;
+            case "PositionSettled":
+                this.emit("positionSettled", event);
+                break;
+        }
+    }
+    send(message) {
+        if (this.ws?.readyState === WS_OPEN) {
+            if (!this.welcomeReceived && message.type !== "Hello") {
+                if (this.enqueuePendingMessage(message)) {
+                    this.log("Queued until Welcome:", message.type);
+                }
+                return;
+            }
+            if (message.type === "Hello") {
+                if (this.helloSent)
+                    return;
+                this.helloSent = true;
+            }
+            this.log("Sending:", message.type);
+            this.ws.send(JSON.stringify(message));
+        }
+        else {
+            this.log("Cannot send, WebSocket not open");
+        }
+    }
+    ensureAuthenticated() {
+        if (this.connectionState !== "authenticated") {
+            throw new Error("Client is not authenticated");
+        }
+    }
+    setConnectionState(state) {
+        if (this.connectionState !== state) {
+            this.connectionState = state;
+            this.emit("stateChange", state);
+        }
+    }
+    startPingInterval() {
+        this.stopPingInterval();
+        this.pingTimer = setInterval(() => this.ping(), this.options.pingInterval);
+    }
+    stopPingInterval() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+    }
+    enqueuePendingMessage(message) {
+        const maxPending = this.options.maxPendingMessages;
+        if (this.pendingMessages.length < maxPending) {
+            this.pendingMessages.push(message);
+            return true;
+        }
+        switch (this.options.pendingMessagesOverflowPolicy) {
+            case "drop_oldest":
+                if (maxPending === 0) {
+                    this.log("Dropping pending message (maxPendingMessages=0):", message.type);
+                    return false;
+                }
+                this.pendingMessages.shift();
+                this.pendingMessages.push(message);
+                this.log("Pending queue full, dropped oldest and queued newest:", message.type);
+                return true;
+            case "drop_newest":
+                this.log("Pending queue full, dropping newest message:", message.type);
+                return false;
+            case "throw":
+                this.emit("error", new Error(`Pending queue overflow (maxPendingMessages=${maxPending}) for message type=${message.type}`));
+                return false;
+        }
+    }
+    stopAutoReconnect() {
+        this.shouldReconnect = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        if (!this.shouldReconnect)
+            return;
+        if (this.reconnectTimer)
+            return;
+        const baseDelay = Math.min(this.options.reconnectDelay * Math.pow(2, this.reconnectAttempts), this.options.maxReconnectDelay);
+        const jitterRatio = this.options.reconnectJitterRatio;
+        const jitterFactor = 1 + (Math.random() * 2 - 1) * jitterRatio;
+        const delay = Math.min(this.options.maxReconnectDelay, Math.max(0, Math.round(baseDelay * jitterFactor)));
+        this.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.reconnectAttempts += 1;
+            this.doConnect();
+        }, delay);
+    }
+    cleanup() {
+        this.stopPingInterval();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.onopen = null;
+            this.ws.onmessage = null;
+            this.ws.onclose = null;
+            this.ws.onerror = null;
+            if (this.ws.readyState === WS_OPEN ||
+                this.ws.readyState === WS_CONNECTING) {
+                try {
+                    this.ws.close();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            this.ws = null;
+        }
+        this.sessionId = null;
+        this.helloSent = false;
+        this.welcomeReceived = false;
+        this.startAuthSent = false;
+        this.pendingMessages = [];
+        this.setConnectionState("disconnected");
+    }
+    log(...args) {
+        if (this.options.debug) {
+            // eslint-disable-next-line no-console
+            console.log("[ActaWsClient]", ...args);
+        }
+    }
+}