@raintree-technology/perps 0.1.0

package/dist/adapters/decibel/ws-feed.js

@@ -0,0 +1,166 @@
+import { EventEmitter } from "node:events";
+import WebSocket from "ws";
+import { createLogger } from "../../lib/logger.js";
+import { isRecord } from "../utils.js";
+const log = createLogger("decibel:ws");
+export class DecibelWsFeed extends EventEmitter {
+    ws = null;
+    wsUrl;
+    bearerToken;
+    subscriptions = new Set();
+    reconnectDelay;
+    pingInterval;
+    pingTimer = null;
+    reconnectTimer = null;
+    shouldReconnect = true;
+    constructor(wsUrl, bearerToken, opts = {}) {
+        super();
+        this.wsUrl = wsUrl;
+        this.bearerToken = bearerToken;
+        this.reconnectDelay = opts.reconnectDelayMs ?? 3_000;
+        this.pingInterval = opts.pingIntervalMs ?? 25_000;
+    }
+    connect() {
+        this.shouldReconnect = true;
+        this.clearReconnectTimer();
+        this.doConnect();
+    }
+    subscribe(topic) {
+        this.subscriptions.add(topic);
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.sendSubscribe(topic);
+        }
+    }
+    unsubscribe(topic) {
+        this.subscriptions.delete(topic);
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ method: "unsubscribe", topic }));
+        }
+    }
+    close() {
+        this.shouldReconnect = false;
+        this.clearReconnectTimer();
+        this.stopPing();
+        this.ws?.removeAllListeners();
+        this.ws?.close();
+        this.ws = null;
+    }
+    isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    doConnect() {
+        if (!this.shouldReconnect) {
+            return;
+        }
+        log.info(`WebSocket connecting: ${this.wsUrl}`);
+        const options = this.bearerToken
+            ? { headers: { "Sec-WebSocket-Protocol": `decibel, ${this.bearerToken}` } }
+            : undefined;
+        this.ws = options ? new WebSocket(this.wsUrl, options) : new WebSocket(this.wsUrl);
+        this.ws.on("open", () => {
+            log.info("WebSocket connected");
+            this.startPing();
+            for (const topic of this.subscriptions) {
+                this.sendSubscribe(topic);
+            }
+        });
+        this.ws.on("message", (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                this.handleMessage(msg);
+            }
+            catch {
+                log.warn("WebSocket parse error");
+            }
+        });
+        this.ws.on("close", (code, reason) => {
+            log.warn(`WebSocket closed (${code}): ${reason.toString()}`);
+            this.stopPing();
+            if (this.shouldReconnect) {
+                this.clearReconnectTimer();
+                this.reconnectTimer = setTimeout(() => {
+                    this.reconnectTimer = null;
+                    this.doConnect();
+                }, this.reconnectDelay);
+            }
+        });
+        this.ws.on("error", (err) => {
+            log.error("WebSocket error", err);
+        });
+    }
+    sendSubscribe(topic) {
+        this.ws?.send(JSON.stringify({ method: "subscribe", topic }));
+    }
+    startPing() {
+        this.stopPing();
+        this.pingTimer = setInterval(() => {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.ping();
+            }
+        }, this.pingInterval);
+    }
+    stopPing() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    handleMessage(msg) {
+        const payload = isRecord(msg) ? msg : {};
+        const topicSource = payload.topic ?? payload.channel;
+        const topic = typeof topicSource === "string" ? topicSource : "";
+        if (topic.startsWith("depth:")) {
+            this.emit("depth", { marketAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        if (topic.startsWith("market_price:")) {
+            const pricePayload = isRecord(payload.price) ? payload.price : payload;
+            this.emit("price", { marketAddr: topic.split(":")[1], data: pricePayload });
+            return;
+        }
+        if (topic === "all_market_prices") {
+            this.emit("all_market_prices", { data: payload });
+            return;
+        }
+        if (topic.startsWith("trades:")) {
+            this.emit("trades", { marketAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        if (topic.startsWith("market_candlestick:")) {
+            const parts = topic.split(":");
+            this.emit("candlestick", { marketAddr: parts[1], interval: parts[2], data: payload });
+            return;
+        }
+        if (topic.startsWith("account_overview:")) {
+            this.emit("account_overview", { accountAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        if (topic.startsWith("account_positions:")) {
+            this.emit("account_positions", { accountAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        if (topic.startsWith("account_open_orders:")) {
+            this.emit("account_open_orders", { accountAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        if (topic.startsWith("order_updates:")) {
+            this.emit("order_updates", { accountAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        if (topic.startsWith("user_trades:")) {
+            this.emit("user_trades", { accountAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        if (topic.startsWith("notifications:")) {
+            this.emit("notifications", { accountAddr: topic.split(":")[1], data: payload });
+            return;
+        }
+        this.emit("raw", payload);
+    }
+}

package/dist/adapters/decibel.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Decibel Adapter
+ * Implements PerpDEXAdapter interface for Decibel (Aptos)
+ */
+import { type Balance, type CancelOrderParams, type ExchangeConfig, type ExchangeInfo, type FundingPayment, type FundingRate, type MarginType, type Market, type ModifyOrderParams, type Order, type OrderBook, type OrderParams, type PerpDEXAdapter, type Position, type PublicTrade, type SubscriptionCallbacks, type Ticker, type Trade, type Unsubscribe, type MMPConfig, type MMPStatus, type TWAPParams, type TWAPStatus } from "./interface.js";
+export declare class DecibelAdapter implements PerpDEXAdapter {
+    readonly info: ExchangeInfo;
+    private config;
+    private connected;
+    private restClient;
+    private wsFeed;
+    private orderManager;
+    private accountAddress;
+    private subaccountAddress;
+    private readonly marketsBySymbol;
+    private readonly marketsByAddr;
+    private readonly pricesByMarketAddr;
+    private readonly booksByMarketAddr;
+    private readonly assetContextsByMarketAddr;
+    private assetContextsTimestamp;
+    private readonly trackedMarketAddrs;
+    private readonly tickerSubscribers;
+    private readonly orderBookSubscribers;
+    private readonly globalSubscribers;
+    private readonly accountPollers;
+    private backfillTimer;
+    connect(config: ExchangeConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getMarkets(): Promise<Market[]>;
+    getMarket(symbol: string): Promise<Market | null>;
+    getTicker(market: string): Promise<Ticker>;
+    getTickers(): Promise<Ticker[]>;
+    getOrderBook(market: string, depth?: number): Promise<OrderBook>;
+    getFundingRate(market: string): Promise<FundingRate>;
+    getFundingRates(): Promise<FundingRate[]>;
+    getPositions(): Promise<Position[]>;
+    getPosition(market: string): Promise<Position | null>;
+    getOrders(market?: string): Promise<Order[]>;
+    getOrder(orderId: string): Promise<Order | null>;
+    getBalances(): Promise<Balance[]>;
+    getTrades(market?: string, limit?: number): Promise<Trade[]>;
+    placeOrder(params: OrderParams): Promise<Order>;
+    cancelOrder(params: CancelOrderParams): Promise<boolean>;
+    cancelAllOrders(market?: string): Promise<number>;
+    setLeverage(market: string, leverage: number): Promise<void>;
+    setMarginType(market: string, type: MarginType): Promise<void>;
+    modifyOrder(_params: ModifyOrderParams): Promise<Order>;
+    batchPlaceOrders(paramsList: OrderParams[]): Promise<Order[]>;
+    batchCancelOrders(paramsList: CancelOrderParams[]): Promise<boolean[]>;
+    cancelAllAfter(_timeoutMs: number): Promise<void>;
+    getOrderHistory(market?: string, limit?: number): Promise<Order[]>;
+    getFundingHistory(_market?: string, _limit?: number): Promise<FundingPayment[]>;
+    getPublicTrades(market: string, limit?: number): Promise<PublicTrade[]>;
+    setMMP(_config: MMPConfig): Promise<void>;
+    getMMP(_market: string): Promise<MMPStatus>;
+    resetMMP(_market: string): Promise<void>;
+    placeTWAP(_params: TWAPParams): Promise<TWAPStatus>;
+    cancelTWAP(_twapId: string): Promise<boolean>;
+    getTWAPStatus(_twapId: string): Promise<TWAPStatus | null>;
+    updateIsolatedMargin(_market: string, _amount: string): Promise<void>;
+    subscribe(callbacks: SubscriptionCallbacks): Unsubscribe;
+    subscribeOrderBook(market: string, callback: (book: OrderBook) => void): Unsubscribe;
+    subscribeTicker(market: string, callback: (ticker: Ticker) => void): Unsubscribe;
+    private loadAssetContexts;
+    private isAssetContextsStale;
+    private handleWsAllMarketPrices;
+    private handleWsAccountOverview;
+    private handleWsAccountPositions;
+    private handleWsAccountOpenOrders;
+    private handleWsUserTrades;
+    private handleWsOrderUpdate;
+    private handleWsNotification;
+    private resolveNetwork;
+    private loadMarkets;
+    private mapMarket;
+    private ensureConnected;
+    private ensureAccountReadAuth;
+    private ensureOrderManager;
+    private requireMarket;
+    private normalizeSymbol;
+    private toTicker;
+    private toPosition;
+    private toOrder;
+    private toTrade;
+    private resolveMarketSymbol;
+    private mapOrderStatus;
+    private mapOrderType;
+    private matchesOrderId;
+    private getCurrentMarginSettings;
+    private normalizeDepth;
+    private toOrderBook;
+    private trackMarket;
+    private handleWsPrice;
+    private handleWsDepth;
+    private handleWsTrades;
+    private startBackfillLoop;
+    private startAccountPollingIfNeeded;
+    private stopAccountPolling;
+    private stopAllAccountPollers;
+    private pollAccountCallbacks;
+    private stopBackfillLoop;
+    private backfillTrackedMarkets;
+    private isBookStale;
+    private isPriceStale;
+    private resolveReferenceExecutionPrice;
+}
+export default DecibelAdapter;