@raintree-technology/perps 0.1.0

package/dist/adapters/decibel.js

@@ -0,0 +1,1377 @@
+/**
+ * Decibel Adapter
+ * Implements PerpDEXAdapter interface for Decibel (Aptos)
+ */
+import { registerAdapter, } from "./interface.js";
+import { DecibelRestClient, } from "./decibel/rest-client.js";
+import { DecibelWsFeed } from "./decibel/ws-feed.js";
+import { DecibelOrderManager, } from "./decibel/order-manager.js";
+import { createLogger } from "../lib/logger.js";
+import { isRecord } from "./utils.js";
+const log = createLogger("decibel");
+const DECIBEL_DEFAULTS = {
+    testnet: {
+        fullnodeUrl: "https://api.testnet.aptoslabs.com/v1",
+        restUrl: "https://api.testnet.aptoslabs.com/decibel",
+        wsUrl: "wss://api.testnet.aptoslabs.com/decibel/ws",
+        packageAddress: "0x95254fcb0816b9f3ec71aa4de5f5f7f8f3efeef9239f0d705a4cd3fe2f452de3",
+    },
+    mainnet: {
+        fullnodeUrl: "https://api.mainnet.aptoslabs.com/v1",
+        restUrl: "https://api.mainnet.aptoslabs.com/decibel",
+        wsUrl: "wss://api.mainnet.aptoslabs.com/decibel/ws",
+        packageAddress: "0xb8a5788314451ce4d2fbbad32e1bad88d4184b73943b7fe5166eab93cf1a5a95",
+    },
+};
+export class DecibelAdapter {
+    info = {
+        id: "decibel",
+        name: "Decibel",
+        type: "dex",
+        chains: ["aptos"],
+        features: {
+            spot: false,
+            perp: true,
+            margin: true,
+            crossMargin: true,
+            isolatedMargin: false,
+            stopOrders: true,
+            takeProfitOrders: true,
+            postOnly: true,
+            reduceOnly: true,
+            subaccounts: true,
+            modifyOrders: false,
+            batchOrders: false,
+            cancelAllAfter: false,
+            publicTrades: true,
+            fundingHistory: false,
+            orderHistory: true,
+            mmp: false,
+            twapOrders: false,
+        },
+        urls: {
+            app: "https://app.decibel.trade",
+            api: "https://api.mainnet.aptoslabs.com/decibel",
+            docs: "https://docs.decibel.trade",
+            testnet: "https://api.testnet.aptoslabs.com/decibel",
+        },
+        implementation: {
+            marketData: "full",
+            authenticatedReads: "full",
+            orderLifecycle: "full",
+            orderCancellation: "full",
+            subscriptions: "full",
+            advancedTrading: "partial",
+        },
+    };
+    config = null;
+    connected = false;
+    restClient = null;
+    wsFeed = null;
+    orderManager = null;
+    accountAddress = null;
+    subaccountAddress = null;
+    marketsBySymbol = new Map();
+    marketsByAddr = new Map();
+    pricesByMarketAddr = new Map();
+    booksByMarketAddr = new Map();
+    assetContextsByMarketAddr = new Map();
+    assetContextsTimestamp = 0;
+    trackedMarketAddrs = new Set();
+    tickerSubscribers = new Map();
+    orderBookSubscribers = new Map();
+    globalSubscribers = new Set();
+    accountPollers = new Map();
+    backfillTimer = null;
+    async connect(config) {
+        this.config = config;
+        const network = this.resolveNetwork(config);
+        const defaults = DECIBEL_DEFAULTS[network];
+        const credentials = config.credentials;
+        const restUrl = credentials?.restUrl ?? defaults.restUrl;
+        const wsUrl = config.wsUrl ?? credentials?.wsUrl ?? defaults.wsUrl;
+        const fullnodeUrl = config.rpcUrl ?? credentials?.fullnodeUrl ?? defaults.fullnodeUrl;
+        const packageAddress = credentials?.packageAddress ?? defaults.packageAddress;
+        this.accountAddress = credentials?.accountAddress ?? credentials?.subaccountAddress ?? null;
+        this.subaccountAddress = credentials?.subaccountAddress ?? credentials?.accountAddress ?? null;
+        this.restClient = new DecibelRestClient(restUrl, credentials?.apiBearerToken);
+        await this.loadMarkets();
+        // Optional WS: if this fails we continue with REST-only fallback.
+        try {
+            this.wsFeed = new DecibelWsFeed(wsUrl, credentials?.apiBearerToken, {
+                reconnectDelayMs: 3_000,
+                pingIntervalMs: 25_000,
+            });
+            this.wsFeed.on("price", ({ marketAddr, data }) => this.handleWsPrice(marketAddr, data));
+            this.wsFeed.on("depth", ({ marketAddr, data }) => this.handleWsDepth(marketAddr, data));
+            this.wsFeed.on("trades", ({ marketAddr, data }) => this.handleWsTrades(marketAddr, data));
+            this.wsFeed.on("all_market_prices", ({ data }) => this.handleWsAllMarketPrices(data));
+            this.wsFeed.on("account_overview", ({ data }) => this.handleWsAccountOverview(data));
+            this.wsFeed.on("account_positions", ({ data }) => this.handleWsAccountPositions(data));
+            this.wsFeed.on("account_open_orders", ({ data }) => this.handleWsAccountOpenOrders(data));
+            this.wsFeed.on("user_trades", ({ data }) => this.handleWsUserTrades(data));
+            this.wsFeed.on("order_updates", ({ data }) => this.handleWsOrderUpdate(data));
+            this.wsFeed.on("notifications", ({ data }) => this.handleWsNotification(data));
+            this.wsFeed.connect();
+            // Subscribe to all_market_prices for global ticker updates
+            this.wsFeed.subscribe("all_market_prices");
+            // Subscribe to account-level channels if we have an account address
+            if (this.subaccountAddress) {
+                this.wsFeed.subscribe(`account_overview:${this.subaccountAddress}`);
+                this.wsFeed.subscribe(`account_positions:${this.subaccountAddress}`);
+                this.wsFeed.subscribe(`account_open_orders:${this.subaccountAddress}`);
+                this.wsFeed.subscribe(`order_updates:${this.subaccountAddress}`);
+                this.wsFeed.subscribe(`user_trades:${this.subaccountAddress}`);
+                this.wsFeed.subscribe(`notifications:${this.subaccountAddress}`);
+            }
+        }
+        catch (err) {
+            this.wsFeed = null;
+            log.warn("WebSocket initialization failed, REST fallback only", err);
+        }
+        // Load initial asset contexts for 24h data
+        try {
+            await this.loadAssetContexts();
+        }
+        catch {
+            log.warn("Failed to load initial asset contexts, 24h data will be unavailable");
+        }
+        this.startBackfillLoop();
+        if (credentials?.privateKey && this.subaccountAddress) {
+            this.orderManager = new DecibelOrderManager({
+                fullnodeUrl,
+                network,
+                packageAddress,
+                privateKey: credentials.privateKey,
+                subaccountAddress: this.subaccountAddress,
+            });
+        }
+        this.connected = true;
+    }
+    async disconnect() {
+        this.stopBackfillLoop();
+        this.stopAllAccountPollers();
+        this.wsFeed?.close();
+        this.wsFeed = null;
+        this.orderManager = null;
+        this.restClient = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async getMarkets() {
+        this.ensureConnected();
+        if (this.marketsBySymbol.size === 0) {
+            await this.loadMarkets();
+        }
+        return Array.from(this.marketsBySymbol.values()).map((m) => ({
+            symbol: m.symbol,
+            baseAsset: m.baseAsset,
+            quoteAsset: m.quoteAsset,
+            type: "perp",
+            maxLeverage: m.maxLeverage,
+            minSize: bigintToDecimalString(m.minSize, m.szDecimals),
+            tickSize: bigintToDecimalString(m.tickSize, m.pxDecimals),
+            fundingInterval: 1,
+            isActive: m.marketMode !== "CloseOnly",
+        }));
+    }
+    async getMarket(symbol) {
+        const normalized = this.normalizeSymbol(symbol);
+        const market = this.marketsBySymbol.get(normalized);
+        if (!market)
+            return null;
+        return {
+            symbol: market.symbol,
+            baseAsset: market.baseAsset,
+            quoteAsset: market.quoteAsset,
+            type: "perp",
+            maxLeverage: market.maxLeverage,
+            minSize: bigintToDecimalString(market.minSize, market.szDecimals),
+            tickSize: bigintToDecimalString(market.tickSize, market.pxDecimals),
+            fundingInterval: 1,
+            isActive: market.marketMode !== "CloseOnly",
+        };
+    }
+    async getTicker(market) {
+        this.ensureConnected();
+        const meta = this.requireMarket(market);
+        this.trackMarket(meta.marketAddr);
+        let price = this.pricesByMarketAddr.get(meta.marketAddr);
+        if (!price || this.isPriceStale(price)) {
+            const prices = await this.restClient.getPrices(meta.marketAddr);
+            price = prices[0];
+            if (price) {
+                this.pricesByMarketAddr.set(meta.marketAddr, price);
+            }
+        }
+        if (!price) {
+            throw new Error(`No ticker price data available for ${market}`);
+        }
+        return this.toTicker(meta, price);
+    }
+    async getTickers() {
+        this.ensureConnected();
+        // Refresh asset contexts for fresh 24h data
+        if (this.isAssetContextsStale()) {
+            try {
+                await this.loadAssetContexts();
+            }
+            catch {
+                // Continue with stale/missing context data
+            }
+        }
+        const prices = await this.restClient.getPrices();
+        for (const price of prices) {
+            this.pricesByMarketAddr.set(price.market, price);
+        }
+        const tickers = [];
+        for (const [marketAddr, price] of this.pricesByMarketAddr.entries()) {
+            const meta = this.marketsByAddr.get(marketAddr);
+            if (!meta)
+                continue;
+            tickers.push(this.toTicker(meta, price));
+        }
+        return tickers;
+    }
+    async getOrderBook(market, depth = 20) {
+        this.ensureConnected();
+        const meta = this.requireMarket(market);
+        this.trackMarket(meta.marketAddr);
+        let cached = this.booksByMarketAddr.get(meta.marketAddr);
+        if (!cached || this.isBookStale(cached.timestamp)) {
+            const depthData = await this.restClient.getDepth(meta.marketAddr, depth);
+            cached = this.normalizeDepth(depthData);
+            this.booksByMarketAddr.set(meta.marketAddr, cached);
+        }
+        return {
+            market: meta.symbol,
+            bids: cached.bids.slice(0, depth).map((b) => ({
+                price: b.price.toString(),
+                size: b.size.toString(),
+            })),
+            asks: cached.asks.slice(0, depth).map((a) => ({
+                price: a.price.toString(),
+                size: a.size.toString(),
+            })),
+            timestamp: cached.timestamp,
+        };
+    }
+    async getFundingRate(market) {
+        const ticker = await this.getTicker(market);
+        return {
+            market: ticker.market,
+            rate: ticker.fundingRate,
+            nextFundingTime: Date.now() + 60 * 60 * 1000,
+            timestamp: ticker.timestamp,
+        };
+    }
+    async getFundingRates() {
+        const tickers = await this.getTickers();
+        return tickers.map((ticker) => ({
+            market: ticker.market,
+            rate: ticker.fundingRate,
+            nextFundingTime: Date.now() + 60 * 60 * 1000,
+            timestamp: ticker.timestamp,
+        }));
+    }
+    async getPositions() {
+        this.ensureConnected();
+        this.ensureAccountReadAuth();
+        const rows = await this.restClient.getAccountPositions(this.accountAddress);
+        return rows
+            .filter((row) => parseNumber(row.size) !== 0)
+            .map((row) => this.toPosition(row));
+    }
+    async getPosition(market) {
+        const normalized = this.normalizeSymbol(market);
+        const positions = await this.getPositions();
+        return positions.find((p) => p.market === normalized) ?? null;
+    }
+    async getOrders(market) {
+        this.ensureConnected();
+        this.ensureAccountReadAuth();
+        const rows = await this.restClient.getOpenOrders(this.accountAddress);
+        const orders = rows
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+        if (!market)
+            return orders;
+        const normalized = this.normalizeSymbol(market);
+        return orders.filter((row) => row.market === normalized);
+    }
+    async getOrder(orderId) {
+        this.ensureConnected();
+        this.ensureAccountReadAuth();
+        // Try all known markets via the direct single-order endpoint first
+        for (const meta of this.marketsBySymbol.values()) {
+            try {
+                const lookup = await this.restClient.getOrderById(this.accountAddress, meta.marketAddr, orderId, undefined);
+                if (lookup.order && lookup.status !== "NotFound") {
+                    return this.toOrder(lookup.order);
+                }
+            }
+            catch {
+                // Continue checking other markets
+            }
+        }
+        // Fall back to scanning open orders + history for client_order_id matches
+        const openRows = await this.restClient.getOpenOrders(this.accountAddress);
+        const openMatch = openRows.find((row) => this.matchesOrderId(row, orderId));
+        if (openMatch) {
+            return this.toOrder(openMatch);
+        }
+        const historyRows = await this.restClient.getOrderHistory(this.accountAddress, 500, 0);
+        const historyMatch = historyRows.find((row) => this.matchesOrderId(row, orderId));
+        if (historyMatch) {
+            return this.toOrder(historyMatch);
+        }
+        return null;
+    }
+    async getBalances() {
+        this.ensureConnected();
+        this.ensureAccountReadAuth();
+        const overview = await this.restClient.getAccountOverview(this.accountAddress);
+        const equity = parseNumber(overview.equity ?? overview.perp_equity_balance);
+        const totalCollateral = parseNumber(overview.total_collateral ?? overview.total_margin);
+        const unrealizedPnl = parseNumber(overview.unrealized_pnl);
+        const marginUsed = Math.max(0, totalCollateral - equity);
+        return [
+            {
+                asset: "USD",
+                total: equity.toString(),
+                available: Math.max(0, equity - marginUsed).toString(),
+                locked: marginUsed.toString(),
+                unrealizedPnl: unrealizedPnl.toString(),
+                marginUsed: marginUsed.toString(),
+            },
+        ];
+    }
+    async getTrades(market, limit = 100) {
+        this.ensureConnected();
+        this.ensureAccountReadAuth();
+        const marketAddr = market ? this.requireMarket(market).marketAddr : undefined;
+        const rows = await this.restClient.getTradeHistory(this.accountAddress, marketAddr, limit, 0);
+        return rows
+            .map((row) => this.toTrade(row))
+            .filter((row) => row !== null);
+    }
+    async placeOrder(params) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        const meta = this.requireMarket(params.market);
+        const side = params.side === "long" ? "buy" : "sell";
+        const sizeUnits = parseNumber(params.size);
+        const timeInForce = params.type === "market" ? 2 : params.postOnly ? 1 : 0;
+        let price = parseNumber(params.price);
+        let stopPrice;
+        let tpTriggerPrice;
+        let tpLimitPrice;
+        let slTriggerPrice;
+        let slLimitPrice;
+        if (params.type === "market") {
+            price = await this.resolveReferenceExecutionPrice(meta, params.side);
+        }
+        if (params.type === "stop" || params.type === "stop_limit") {
+            stopPrice = parseNumber(params.triggerPrice ?? params.price);
+            if (!price || price <= 0) {
+                price = stopPrice;
+            }
+        }
+        if (params.type === "take_profit") {
+            tpTriggerPrice = parseNumber(params.triggerPrice);
+            tpLimitPrice = parseNumber(params.price ?? params.triggerPrice);
+            if (!price || price <= 0) {
+                price = tpLimitPrice;
+            }
+        }
+        if (!Number.isFinite(price) || price <= 0) {
+            throw new Error("Order price could not be resolved");
+        }
+        if (params.type === "stop_limit") {
+            slTriggerPrice = stopPrice;
+            slLimitPrice = price;
+        }
+        const txHash = await this.orderManager.placeOrder({
+            market: meta,
+            side,
+            price,
+            sizeUnits,
+            timeInForce,
+            reduceOnly: params.reduceOnly ?? false,
+            clientOrderId: params.clientOrderId,
+            stopPrice,
+            tpTriggerPrice,
+            tpLimitPrice,
+            slTriggerPrice,
+            slLimitPrice,
+        });
+        return {
+            id: txHash,
+            market: meta.symbol,
+            side: params.side,
+            type: params.type,
+            size: params.size,
+            price: price.toString(),
+            filled: "0",
+            remaining: params.size,
+            status: "open",
+            reduceOnly: params.reduceOnly ?? false,
+            postOnly: params.postOnly ?? false,
+            timestamp: Date.now(),
+            triggerPrice: params.triggerPrice,
+        };
+    }
+    async cancelOrder(params) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        if (!params.orderId) {
+            throw new Error("Decibel cancelOrder requires orderId");
+        }
+        let market = params.market;
+        if (!market) {
+            const existing = await this.getOrder(params.orderId);
+            market = existing?.market;
+        }
+        if (!market) {
+            throw new Error("Decibel cancelOrder requires market or resolvable orderId");
+        }
+        const meta = this.requireMarket(market);
+        await this.orderManager.cancelOrder(params.orderId, meta.marketAddr);
+        return true;
+    }
+    async cancelAllOrders(market) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        if (market) {
+            const meta = this.requireMarket(market);
+            await this.orderManager.cancelAllOrders(meta.marketAddr);
+            return 1;
+        }
+        let cancelled = 0;
+        for (const meta of this.marketsBySymbol.values()) {
+            try {
+                await this.orderManager.cancelAllOrders(meta.marketAddr);
+                cancelled++;
+            }
+            catch {
+                // Continue best-effort cancel on other markets.
+            }
+        }
+        return cancelled;
+    }
+    async setLeverage(market, leverage) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        if (!Number.isFinite(leverage) || leverage <= 0) {
+            throw new Error("Leverage must be a positive number");
+        }
+        const meta = this.requireMarket(market);
+        const current = await this.getCurrentMarginSettings(meta.symbol);
+        const leverageBps = Math.max(1, Math.round(leverage * 100));
+        await this.orderManager.configureUserSettingsForMarket(meta.marketAddr, current.isCross, leverageBps);
+    }
+    async setMarginType(market, type) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        const meta = this.requireMarket(market);
+        const current = await this.getCurrentMarginSettings(meta.symbol);
+        const isCross = type === "cross";
+        await this.orderManager.configureUserSettingsForMarket(meta.marketAddr, isCross, current.userLeverageBps);
+    }
+    // --------------------------------------------------------------------------
+    // Advanced Trading
+    // --------------------------------------------------------------------------
+    async modifyOrder(_params) {
+        throw new Error("Decibel does not support order modification. Cancel and replace instead.");
+    }
+    async batchPlaceOrders(paramsList) {
+        const results = [];
+        for (const params of paramsList) {
+            results.push(await this.placeOrder(params));
+        }
+        return results;
+    }
+    async batchCancelOrders(paramsList) {
+        const results = [];
+        for (const params of paramsList) {
+            try {
+                results.push(await this.cancelOrder(params));
+            }
+            catch {
+                results.push(false);
+            }
+        }
+        return results;
+    }
+    async cancelAllAfter(_timeoutMs) {
+        throw new Error("Decibel does not support cancelAllAfter (dead man's switch)");
+    }
+    async getOrderHistory(market, limit = 100) {
+        this.ensureConnected();
+        this.ensureAccountReadAuth();
+        const rows = await this.restClient.getOrderHistory(this.accountAddress, limit, 0);
+        let orders = rows
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+        if (market) {
+            const normalized = this.normalizeSymbol(market);
+            orders = orders.filter((o) => o.market === normalized);
+        }
+        return orders;
+    }
+    async getFundingHistory(_market, _limit) {
+        // Decibel does not expose a funding payment history endpoint
+        return [];
+    }
+    async getPublicTrades(market, limit = 100) {
+        this.ensureConnected();
+        const meta = this.requireMarket(market);
+        const rows = await this.restClient.getPublicTrades(meta.marketAddr, limit);
+        return rows.map((row) => {
+            const price = parseNumber(row.price);
+            const size = parseNumber(row.size);
+            const sideValue = row.action === "sell" ? "short" : "long";
+            return {
+                id: row.trade_id ?? `${meta.symbol}-${Date.now()}`,
+                market: meta.symbol,
+                side: sideValue,
+                price: price.toString(),
+                size: size.toString(),
+                timestamp: parseNumber(row.transaction_unix_ms) || Date.now(),
+            };
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Market Maker Protection
+    // --------------------------------------------------------------------------
+    async setMMP(_config) {
+        throw new Error("Decibel does not support Market Maker Protection (MMP)");
+    }
+    async getMMP(_market) {
+        throw new Error("Decibel does not support Market Maker Protection (MMP)");
+    }
+    async resetMMP(_market) {
+        throw new Error("Decibel does not support Market Maker Protection (MMP)");
+    }
+    // --------------------------------------------------------------------------
+    // TWAP Orders
+    // --------------------------------------------------------------------------
+    async placeTWAP(_params) {
+        throw new Error("Decibel does not support TWAP orders");
+    }
+    async cancelTWAP(_twapId) {
+        throw new Error("Decibel does not support TWAP orders");
+    }
+    async getTWAPStatus(_twapId) {
+        throw new Error("Decibel does not support TWAP orders");
+    }
+    // --------------------------------------------------------------------------
+    // Margin Management
+    // --------------------------------------------------------------------------
+    async updateIsolatedMargin(_market, _amount) {
+        throw new Error("Decibel does not support isolated margin adjustment");
+    }
+    subscribe(callbacks) {
+        this.globalSubscribers.add(callbacks);
+        this.startAccountPollingIfNeeded(callbacks);
+        return () => {
+            this.globalSubscribers.delete(callbacks);
+            this.stopAccountPolling(callbacks);
+        };
+    }
+    subscribeOrderBook(market, callback) {
+        const meta = this.requireMarket(market);
+        this.trackMarket(meta.marketAddr);
+        this.wsFeed?.subscribe(`depth:${meta.marketAddr}`);
+        if (!this.orderBookSubscribers.has(meta.symbol)) {
+            this.orderBookSubscribers.set(meta.symbol, new Set());
+        }
+        const subscribers = this.orderBookSubscribers.get(meta.symbol);
+        subscribers.add(callback);
+        const cached = this.booksByMarketAddr.get(meta.marketAddr);
+        if (cached) {
+            callback(this.toOrderBook(meta, cached));
+        }
+        return () => {
+            subscribers.delete(callback);
+            if (subscribers.size === 0) {
+                this.orderBookSubscribers.delete(meta.symbol);
+            }
+        };
+    }
+    subscribeTicker(market, callback) {
+        const meta = this.requireMarket(market);
+        this.trackMarket(meta.marketAddr);
+        this.wsFeed?.subscribe(`market_price:${meta.marketAddr}`);
+        if (!this.tickerSubscribers.has(meta.symbol)) {
+            this.tickerSubscribers.set(meta.symbol, new Set());
+        }
+        const subscribers = this.tickerSubscribers.get(meta.symbol);
+        subscribers.add(callback);
+        const cached = this.pricesByMarketAddr.get(meta.marketAddr);
+        if (cached) {
+            callback(this.toTicker(meta, cached));
+        }
+        return () => {
+            subscribers.delete(callback);
+            if (subscribers.size === 0) {
+                this.tickerSubscribers.delete(meta.symbol);
+            }
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Internal helpers
+    // --------------------------------------------------------------------------
+    async loadAssetContexts() {
+        if (!this.restClient)
+            return;
+        const contexts = await this.restClient.getAssetContexts();
+        for (const ctx of contexts) {
+            this.assetContextsByMarketAddr.set(ctx.market, ctx);
+        }
+        this.assetContextsTimestamp = Date.now();
+    }
+    isAssetContextsStale() {
+        return Date.now() - this.assetContextsTimestamp > 60_000;
+    }
+    handleWsAllMarketPrices(data) {
+        if (!isRecord(data))
+            return;
+        // all_market_prices can carry an array of price objects or a data wrapper
+        const items = Array.isArray(data.data)
+            ? data.data
+            : Array.isArray(data.prices)
+                ? data.prices
+                : [];
+        for (const item of items) {
+            if (!isRecord(item))
+                continue;
+            const marketAddr = typeof item.market === "string" ? item.market : undefined;
+            if (!marketAddr)
+                continue;
+            this.handleWsPrice(marketAddr, item);
+        }
+    }
+    handleWsAccountOverview(data) {
+        if (!isRecord(data))
+            return;
+        for (const callbacks of this.globalSubscribers) {
+            if (!callbacks.onBalances)
+                continue;
+            try {
+                const equity = parseNumber(toNumericInput(data.equity) ?? toNumericInput(data.perp_equity_balance));
+                const totalCollateral = parseNumber(toNumericInput(data.total_collateral) ?? toNumericInput(data.total_margin));
+                const unrealizedPnl = parseNumber(toNumericInput(data.unrealized_pnl));
+                const marginUsed = Math.max(0, totalCollateral - equity);
+                callbacks.onBalances([{
+                        asset: "USD",
+                        total: equity.toString(),
+                        available: Math.max(0, equity - marginUsed).toString(),
+                        locked: marginUsed.toString(),
+                        unrealizedPnl: unrealizedPnl.toString(),
+                        marginUsed: marginUsed.toString(),
+                    }]);
+            }
+            catch (err) {
+                callbacks.onError?.(toError(err));
+            }
+        }
+    }
+    handleWsAccountPositions(data) {
+        if (!isRecord(data))
+            return;
+        const rows = Array.isArray(data.positions)
+            ? data.positions
+            : Array.isArray(data.data)
+                ? data.data
+                : Array.isArray(data)
+                    ? data
+                    : [];
+        const positions = [];
+        for (const row of rows) {
+            if (!isRecord(row))
+                continue;
+            const size = parseNumber(toNumericInput(row.size));
+            if (size === 0)
+                continue;
+            positions.push(this.toPosition(row));
+        }
+        for (const callbacks of this.globalSubscribers) {
+            callbacks.onPositions?.(positions);
+        }
+    }
+    handleWsAccountOpenOrders(data) {
+        if (!isRecord(data))
+            return;
+        const rows = Array.isArray(data.orders)
+            ? data.orders
+            : Array.isArray(data.data)
+                ? data.data
+                : Array.isArray(data)
+                    ? data
+                    : [];
+        const orders = [];
+        for (const row of rows) {
+            if (!isRecord(row))
+                continue;
+            const order = this.toOrder(row);
+            if (order)
+                orders.push(order);
+        }
+        for (const callbacks of this.globalSubscribers) {
+            callbacks.onOrders?.(orders);
+        }
+    }
+    handleWsUserTrades(data) {
+        if (!isRecord(data))
+            return;
+        const rows = Array.isArray(data.trades)
+            ? data.trades
+            : Array.isArray(data.data)
+                ? data.data
+                : Array.isArray(data)
+                    ? data
+                    : [];
+        const trades = [];
+        for (const row of rows) {
+            if (!isRecord(row))
+                continue;
+            const trade = this.toTrade(row);
+            if (trade)
+                trades.push(trade);
+        }
+        if (trades.length > 0) {
+            for (const callbacks of this.globalSubscribers) {
+                callbacks.onTrades?.(trades);
+            }
+        }
+    }
+    handleWsOrderUpdate(data) {
+        if (!isRecord(data))
+            return;
+        // order_updates carries a single order status change
+        const orderData = isRecord(data.order) ? data.order : data;
+        const order = this.toOrder(orderData);
+        if (!order)
+            return;
+        for (const callbacks of this.globalSubscribers) {
+            callbacks.onOrders?.([order]);
+        }
+    }
+    handleWsNotification(data) {
+        if (!isRecord(data))
+            return;
+        // Notifications include liquidation alerts - log them for observability
+        log.warn("Decibel notification received", data);
+    }
+    resolveNetwork(config) {
+        const fromCredentials = config.credentials?.network;
+        if (fromCredentials === "testnet" || fromCredentials === "mainnet") {
+            return fromCredentials;
+        }
+        return config.testnet ? "testnet" : "mainnet";
+    }
+    async loadMarkets() {
+        const rows = await this.restClient.getMarkets();
+        this.marketsBySymbol.clear();
+        this.marketsByAddr.clear();
+        for (const row of rows) {
+            const meta = this.mapMarket(row);
+            this.marketsBySymbol.set(meta.symbol, meta);
+            this.marketsByAddr.set(meta.marketAddr, meta);
+        }
+    }
+    mapMarket(row) {
+        const marketName = row.market_name;
+        const baseAsset = marketName.split("/")[0]?.toUpperCase() ?? marketName.toUpperCase();
+        const quoteAsset = marketName.split("/")[1]?.toUpperCase() ?? "USD";
+        return {
+            marketName,
+            marketAddr: row.market_addr,
+            symbol: `${baseAsset}-PERP`,
+            baseAsset,
+            quoteAsset,
+            maxLeverage: parseNumber(row.max_leverage) || 20,
+            pxDecimals: parseInt(String(row.px_decimals), 10),
+            szDecimals: parseInt(String(row.sz_decimals), 10),
+            tickSize: BigInt(String(row.tick_size)),
+            lotSize: BigInt(String(row.lot_size)),
+            minSize: BigInt(String(row.min_size)),
+            marketMode: row.market_mode,
+        };
+    }
+    ensureConnected() {
+        if (!this.connected || !this.restClient) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+    }
+    ensureAccountReadAuth() {
+        if (!this.accountAddress) {
+            throw new Error("Decibel account reads require account address (set DECIBEL_API_WALLET_ADDRESS or subaccount).");
+        }
+        if (!this.config?.credentials?.apiBearerToken) {
+            throw new Error("Decibel account reads require DECIBEL_API_BEARER_TOKEN.");
+        }
+    }
+    ensureOrderManager() {
+        if (!this.orderManager) {
+            throw new Error("Decibel trading requires private key + package settings + subaccount (DECIBEL_API_WALLET_PRIVATE_KEY, DECIBEL_API_WALLET_ADDRESS, DECIBEL_API_BEARER_TOKEN).");
+        }
+    }
+    requireMarket(symbol) {
+        const raw = symbol.trim();
+        const byAddress = this.marketsByAddr.get(raw);
+        if (byAddress) {
+            return byAddress;
+        }
+        const normalized = this.normalizeSymbol(symbol);
+        const market = this.marketsBySymbol.get(normalized);
+        if (!market) {
+            throw new Error(`Market not found on Decibel: ${symbol}`);
+        }
+        return market;
+    }
+    normalizeSymbol(symbol) {
+        const upper = symbol.toUpperCase().trim();
+        if (upper.endsWith("-PERP"))
+            return upper;
+        if (upper.includes("/")) {
+            return `${upper.split("/")[0]}-PERP`;
+        }
+        return `${upper}-PERP`;
+    }
+    toTicker(meta, price) {
+        const markPrice = parseNumber(price.mark_px);
+        const midPrice = parseNumber(price.mid_px) || markPrice;
+        const oraclePrice = parseNumber(price.oracle_px) || markPrice;
+        const rawFundingBps = parseNumber(price.funding_rate_bps);
+        const isFundingPositive = price.is_funding_positive;
+        const fundingRate = isFundingPositive === false
+            ? -Math.abs(rawFundingBps / 10_000)
+            : rawFundingBps / 10_000;
+        const openInterest = parseNumber(price.open_interest);
+        const book = this.booksByMarketAddr.get(meta.marketAddr);
+        const bid = book?.bids[0]?.price ?? midPrice;
+        const ask = book?.asks[0]?.price ?? midPrice;
+        const timestamp = parseNumber(price.transaction_unix_ms) || Date.now();
+        // Pull 24h data from asset contexts cache
+        const ctx = this.assetContextsByMarketAddr.get(meta.marketAddr);
+        const volume24h = ctx ? parseNumber(ctx.volume_24h) : 0;
+        const change24h = ctx ? parseNumber(ctx.price_change_pct_24h) : 0;
+        return {
+            market: meta.symbol,
+            lastPrice: midPrice.toString(),
+            markPrice: markPrice.toString(),
+            indexPrice: oraclePrice.toString(),
+            bid: bid.toString(),
+            ask: ask.toString(),
+            volume24h: volume24h.toString(),
+            change24h: change24h.toString(),
+            high24h: "0",
+            low24h: "0",
+            openInterest: openInterest.toString(),
+            fundingRate: fundingRate.toString(),
+            timestamp,
+        };
+    }
+    toPosition(row) {
+        const rawSize = parseNumber(row.size);
+        const marketName = row.market_name ?? row.market ?? "UNKNOWN";
+        const side = rawSize >= 0 ? "long" : "short";
+        return {
+            market: this.normalizeSymbol(marketName),
+            side,
+            size: Math.abs(rawSize).toString(),
+            entryPrice: parseNumber(row.entry_price).toString(),
+            markPrice: parseNumber(row.mark_price ?? row.oracle_price).toString(),
+            liquidationPrice: parseNumber(row.liquidation_price ?? row.estimated_liquidation_price).toString(),
+            unrealizedPnl: parseNumber(row.unrealized_pnl ?? row.unrealized_funding).toString(),
+            realizedPnl: "0",
+            leverage: parseNumber(row.leverage ?? row.user_leverage) || 1,
+            marginType: "cross",
+            margin: "0",
+            timestamp: Date.now(),
+        };
+    }
+    toOrder(row) {
+        const marketRaw = row.market_name ?? row.market ?? "UNKNOWN";
+        const market = this.resolveMarketSymbol(marketRaw);
+        if (!market)
+            return null;
+        const totalSize = parseNumber(row.orig_size ?? row.filled_size ?? row.remaining_size);
+        const remainingSize = parseNumber(row.remaining_size);
+        const filledSize = Math.max(0, totalSize - remainingSize);
+        const priceValue = parseNumber(row.price);
+        const triggerPriceValue = parseNumber(row.trigger_price);
+        return {
+            id: row.order_id ?? row.client_order_id ?? `order-${Date.now()}`,
+            market,
+            side: row.is_buy === false || row.side === "sell" ? "short" : "long",
+            type: this.mapOrderType(row.order_type),
+            size: totalSize.toString(),
+            price: priceValue > 0 ? priceValue.toString() : null,
+            filled: filledSize.toString(),
+            remaining: Math.max(0, remainingSize).toString(),
+            status: this.mapOrderStatus(row.status),
+            reduceOnly: toBoolean(row.is_reduce_only ?? row.reduce_only),
+            postOnly: toBoolean(row.is_post_only ?? row.post_only),
+            timestamp: parseNumber(row.unix_ms) || Date.now(),
+            triggerPrice: triggerPriceValue > 0 ? triggerPriceValue.toString() : undefined,
+        };
+    }
+    toTrade(row) {
+        const marketRaw = row.market_name ?? row.market ?? "UNKNOWN";
+        const market = this.resolveMarketSymbol(marketRaw);
+        if (!market)
+            return null;
+        const orderId = row.order_id;
+        const price = parseNumber(row.price);
+        const size = parseNumber(row.size);
+        if (size <= 0)
+            return null;
+        return {
+            id: row.trade_id ?? row.fill_id ?? `${orderId ?? market}-${Date.now()}`,
+            market,
+            side: row.is_buy === false || row.side === "sell" ? "short" : "long",
+            price: price.toString(),
+            size: size.toString(),
+            fee: parseNumber(row.fee).toString(),
+            feeAsset: row.fee_asset ?? "USD",
+            timestamp: parseNumber(row.unix_ms) || Date.now(),
+            ...(orderId ? { orderId } : {}),
+        };
+    }
+    resolveMarketSymbol(input) {
+        const raw = input.trim();
+        if (!raw)
+            return null;
+        const byAddress = this.marketsByAddr.get(raw);
+        if (byAddress)
+            return byAddress.symbol;
+        return this.normalizeSymbol(raw);
+    }
+    mapOrderStatus(status) {
+        const normalized = status?.toLowerCase() ?? "open";
+        if (normalized.includes("fill"))
+            return "filled";
+        if (normalized.includes("cancel"))
+            return "cancelled";
+        if (normalized.includes("expire"))
+            return "expired";
+        if (normalized.includes("partial"))
+            return "partial";
+        return "open";
+    }
+    mapOrderType(type) {
+        const normalized = type?.toLowerCase() ?? "limit";
+        if (normalized.includes("market"))
+            return "market";
+        if (normalized.includes("stop_limit"))
+            return "stop_limit";
+        if (normalized.includes("stop"))
+            return "stop";
+        if (normalized.includes("take"))
+            return "take_profit";
+        return "limit";
+    }
+    matchesOrderId(row, orderId) {
+        return row.order_id === orderId || row.client_order_id === orderId;
+    }
+    async getCurrentMarginSettings(market) {
+        const defaults = { isCross: true, userLeverageBps: 100 };
+        if (!this.accountAddress || !this.config?.credentials?.apiBearerToken) {
+            return defaults;
+        }
+        try {
+            const position = await this.getPosition(market);
+            if (!position)
+                return defaults;
+            return {
+                isCross: position.marginType === "cross",
+                userLeverageBps: Math.max(1, Math.round(position.leverage * 100)),
+            };
+        }
+        catch {
+            return defaults;
+        }
+    }
+    normalizeDepth(depth) {
+        const bids = (depth.bids ?? []).map((level) => ({
+            price: parseNumber(level.price),
+            size: parseNumber(level.size),
+        }));
+        const asks = (depth.asks ?? []).map((level) => ({
+            price: parseNumber(level.price),
+            size: parseNumber(level.size),
+        }));
+        bids.sort((a, b) => b.price - a.price);
+        asks.sort((a, b) => a.price - b.price);
+        return {
+            bids,
+            asks,
+            timestamp: parseNumber(depth.unix_ms) || Date.now(),
+        };
+    }
+    toOrderBook(meta, cached) {
+        return {
+            market: meta.symbol,
+            bids: cached.bids.map((b) => ({ price: b.price.toString(), size: b.size.toString() })),
+            asks: cached.asks.map((a) => ({ price: a.price.toString(), size: a.size.toString() })),
+            timestamp: cached.timestamp,
+        };
+    }
+    trackMarket(marketAddr) {
+        if (this.trackedMarketAddrs.has(marketAddr))
+            return;
+        this.trackedMarketAddrs.add(marketAddr);
+        this.wsFeed?.subscribe(`market_price:${marketAddr}`);
+        this.wsFeed?.subscribe(`depth:${marketAddr}`);
+        this.wsFeed?.subscribe(`trades:${marketAddr}`);
+    }
+    handleWsPrice(marketAddr, data) {
+        const payload = coerceWsPricePayload(marketAddr, data);
+        this.pricesByMarketAddr.set(marketAddr, payload);
+        const meta = this.marketsByAddr.get(marketAddr);
+        if (!meta)
+            return;
+        const ticker = this.toTicker(meta, payload);
+        const subs = this.tickerSubscribers.get(meta.symbol);
+        if (subs) {
+            for (const cb of subs)
+                cb(ticker);
+        }
+        for (const callbacks of this.globalSubscribers) {
+            callbacks.onTicker?.(ticker);
+        }
+    }
+    handleWsDepth(marketAddr, data) {
+        const normalized = this.normalizeDepth({
+            market: marketAddr,
+            bids: coerceWsDepthLevels(data, "bids"),
+            asks: coerceWsDepthLevels(data, "asks"),
+            unix_ms: Date.now(),
+        });
+        this.booksByMarketAddr.set(marketAddr, normalized);
+        const meta = this.marketsByAddr.get(marketAddr);
+        if (!meta)
+            return;
+        const book = this.toOrderBook(meta, normalized);
+        const subs = this.orderBookSubscribers.get(meta.symbol);
+        if (subs) {
+            for (const cb of subs)
+                cb(book);
+        }
+        for (const callbacks of this.globalSubscribers) {
+            callbacks.onOrderBook?.(book);
+        }
+    }
+    handleWsTrades(marketAddr, data) {
+        const meta = this.marketsByAddr.get(marketAddr);
+        if (!meta)
+            return;
+        const trades = coerceWsTrades(data, meta.symbol);
+        if (trades.length === 0)
+            return;
+        for (const callbacks of this.globalSubscribers) {
+            callbacks.onTrades?.(trades);
+        }
+    }
+    startBackfillLoop() {
+        this.stopBackfillLoop();
+        this.backfillTimer = setInterval(() => {
+            this.backfillTrackedMarkets().catch((err) => {
+                log.warn("Decibel REST backfill failed", err);
+            });
+        }, 60_000);
+    }
+    startAccountPollingIfNeeded(callbacks) {
+        const needsAccountData = !!callbacks.onPositions ||
+            !!callbacks.onOrders ||
+            !!callbacks.onBalances ||
+            !!callbacks.onTrades;
+        if (!needsAccountData)
+            return;
+        if (!this.config?.credentials?.apiBearerToken || !this.accountAddress)
+            return;
+        // If WebSocket account channels are subscribed, we rely on push updates
+        // but still do an initial REST poll to seed the state
+        this.pollAccountCallbacks(callbacks).catch((err) => callbacks.onError?.(toError(err)));
+        // Use a slower polling cadence as a safety net (WS push is primary)
+        const pollInterval = this.wsFeed && this.subaccountAddress ? 30_000 : 5_000;
+        const timer = setInterval(() => {
+            this.pollAccountCallbacks(callbacks).catch((err) => callbacks.onError?.(toError(err)));
+        }, pollInterval);
+        this.accountPollers.set(callbacks, timer);
+    }
+    stopAccountPolling(callbacks) {
+        const timer = this.accountPollers.get(callbacks);
+        if (!timer)
+            return;
+        clearInterval(timer);
+        this.accountPollers.delete(callbacks);
+    }
+    stopAllAccountPollers() {
+        for (const timer of this.accountPollers.values()) {
+            clearInterval(timer);
+        }
+        this.accountPollers.clear();
+    }
+    async pollAccountCallbacks(callbacks) {
+        if (callbacks.onPositions) {
+            const positions = await this.getPositions();
+            callbacks.onPositions(positions);
+        }
+        if (callbacks.onOrders) {
+            const orders = await this.getOrders();
+            callbacks.onOrders(orders);
+        }
+        if (callbacks.onBalances) {
+            const balances = await this.getBalances();
+            callbacks.onBalances(balances);
+        }
+        if (callbacks.onTrades) {
+            const trades = await this.getTrades(undefined, 100);
+            callbacks.onTrades(trades);
+        }
+    }
+    stopBackfillLoop() {
+        if (this.backfillTimer) {
+            clearInterval(this.backfillTimer);
+            this.backfillTimer = null;
+        }
+    }
+    async backfillTrackedMarkets() {
+        if (!this.restClient || this.trackedMarketAddrs.size === 0) {
+            return;
+        }
+        // Refresh asset contexts for 24h data
+        if (this.isAssetContextsStale()) {
+            try {
+                await this.loadAssetContexts();
+            }
+            catch {
+                log.warn("Failed to refresh asset contexts during backfill");
+            }
+        }
+        const prices = await this.restClient.getPrices();
+        for (const price of prices) {
+            if (!this.trackedMarketAddrs.has(price.market))
+                continue;
+            this.pricesByMarketAddr.set(price.market, price);
+            const meta = this.marketsByAddr.get(price.market);
+            if (meta) {
+                const ticker = this.toTicker(meta, price);
+                const subs = this.tickerSubscribers.get(meta.symbol);
+                if (subs) {
+                    for (const cb of subs)
+                        cb(ticker);
+                }
+                for (const callbacks of this.globalSubscribers) {
+                    callbacks.onTicker?.(ticker);
+                }
+            }
+        }
+        for (const marketAddr of this.trackedMarketAddrs) {
+            try {
+                const depth = await this.restClient.getDepth(marketAddr);
+                const normalizedDepth = this.normalizeDepth(depth);
+                this.booksByMarketAddr.set(marketAddr, normalizedDepth);
+                const meta = this.marketsByAddr.get(marketAddr);
+                if (meta) {
+                    const book = this.toOrderBook(meta, normalizedDepth);
+                    const subs = this.orderBookSubscribers.get(meta.symbol);
+                    if (subs) {
+                        for (const cb of subs)
+                            cb(book);
+                    }
+                    for (const callbacks of this.globalSubscribers) {
+                        callbacks.onOrderBook?.(book);
+                    }
+                }
+            }
+            catch {
+                // Keep processing remaining markets.
+            }
+        }
+    }
+    isBookStale(timestamp) {
+        return Date.now() - timestamp > 5_000;
+    }
+    isPriceStale(price) {
+        const ts = parseNumber(price.transaction_unix_ms);
+        if (!ts)
+            return true;
+        return Date.now() - ts > 10_000;
+    }
+    async resolveReferenceExecutionPrice(meta, side) {
+        try {
+            const book = await this.getOrderBook(meta.symbol, 1);
+            const bestBid = parseNumber(book.bids[0]?.price);
+            const bestAsk = parseNumber(book.asks[0]?.price);
+            if (bestBid > 0 && bestAsk > 0) {
+                return side === "long" ? bestAsk : bestBid;
+            }
+        }
+        catch {
+            // fallback to ticker below
+        }
+        const ticker = await this.getTicker(meta.symbol);
+        const mark = parseNumber(ticker.markPrice);
+        if (mark <= 0) {
+            throw new Error(`Could not resolve execution price for ${meta.symbol}`);
+        }
+        return mark;
+    }
+}
+function parseNumber(value) {
+    if (value === undefined)
+        return 0;
+    const num = Number(value);
+    return Number.isFinite(num) ? num : 0;
+}
+function toBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string")
+        return value.toLowerCase() === "true";
+    return false;
+}
+function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+function toNumericInput(value) {
+    if (typeof value === "string" || typeof value === "number") {
+        return value;
+    }
+    return undefined;
+}
+function coerceWsPricePayload(marketAddr, data) {
+    const payload = isRecord(data) ? data : {};
+    const market = typeof payload.market === "string" ? payload.market : marketAddr;
+    return {
+        market,
+        oracle_px: toNumericInput(payload.oracle_px) ?? 0,
+        mark_px: toNumericInput(payload.mark_px) ?? 0,
+        mid_px: toNumericInput(payload.mid_px) ?? 0,
+        funding_rate_bps: toNumericInput(payload.funding_rate_bps) ?? 0,
+        open_interest: toNumericInput(payload.open_interest) ?? 0,
+        transaction_unix_ms: toNumericInput(payload.transaction_unix_ms),
+    };
+}
+function coerceWsDepthLevels(data, side) {
+    const payload = isRecord(data) ? data : {};
+    const rawLevels = payload[side];
+    if (!Array.isArray(rawLevels)) {
+        return [];
+    }
+    const levels = [];
+    for (const rawLevel of rawLevels) {
+        if (!isRecord(rawLevel))
+            continue;
+        const price = toNumericInput(rawLevel.price);
+        const size = toNumericInput(rawLevel.size);
+        if (price === undefined || size === undefined)
+            continue;
+        levels.push({ price, size });
+    }
+    return levels;
+}
+function coerceWsTrades(data, fallbackMarket) {
+    const source = isRecord(data) ? data : {};
+    const candidates = [
+        source.trades,
+        source.data,
+        isRecord(source.data) ? source.data.trades : undefined,
+    ];
+    let rows = [];
+    if (Array.isArray(data)) {
+        rows = data;
+    }
+    else {
+        for (const candidate of candidates) {
+            if (Array.isArray(candidate)) {
+                rows = candidate;
+                break;
+            }
+        }
+    }
+    if (rows.length === 0)
+        return [];
+    const trades = [];
+    for (const row of rows) {
+        if (!isRecord(row))
+            continue;
+        const price = parseNumber(toNumericInput(row.price));
+        const size = parseNumber(toNumericInput(row.size) ??
+            toNumericInput(row.qty) ??
+            toNumericInput(row.quantity) ??
+            toNumericInput(row.sz));
+        if (price <= 0 || size <= 0)
+            continue;
+        const market = normalizeWsMarketSymbol(typeof row.market_name === "string"
+            ? row.market_name
+            : typeof row.market === "string"
+                ? row.market
+                : fallbackMarket, fallbackMarket);
+        const sideValue = typeof row.side === "string"
+            ? row.side
+            : toBoolean(row.is_buy)
+                ? "buy"
+                : "sell";
+        const side = sideValue.toLowerCase().startsWith("buy") ? "long" : "short";
+        const orderId = typeof row.order_id === "string"
+            ? row.order_id
+            : typeof row.orderId === "string"
+                ? row.orderId
+                : undefined;
+        trades.push({
+            id: (typeof row.trade_id === "string" && row.trade_id) ||
+                (typeof row.fill_id === "string" && row.fill_id) ||
+                (typeof row.id === "string" && row.id) ||
+                `${market}-${Date.now()}-${trades.length}`,
+            market,
+            side,
+            price: price.toString(),
+            size: size.toString(),
+            fee: parseNumber(toNumericInput(row.fee)).toString(),
+            feeAsset: (typeof row.fee_asset === "string" && row.fee_asset) ||
+                (typeof row.feeAsset === "string" && row.feeAsset) ||
+                "USD",
+            timestamp: parseNumber(toNumericInput(row.unix_ms) ??
+                toNumericInput(row.timestamp) ??
+                toNumericInput(row.ts) ??
+                toNumericInput(row.time)) || Date.now(),
+            ...(orderId ? { orderId } : {}),
+        });
+    }
+    return trades;
+}
+function normalizeWsMarketSymbol(raw, fallbackMarket) {
+    const value = raw.trim();
+    if (!value)
+        return fallbackMarket;
+    const upper = value.toUpperCase();
+    if (upper.endsWith("-PERP"))
+        return upper;
+    if (upper.includes("/")) {
+        return `${upper.split("/")[0]}-PERP`;
+    }
+    // Trade feed can carry market addresses; fallback to the subscribed symbol in that case.
+    if (upper.startsWith("0X"))
+        return fallbackMarket;
+    return `${upper}-PERP`;
+}
+function bigintToDecimalString(units, decimals) {
+    if (decimals <= 0)
+        return units.toString();
+    const base = 10n ** BigInt(decimals);
+    const whole = units / base;
+    const frac = (units % base).toString().padStart(decimals, "0").replace(/0+$/, "");
+    return frac.length > 0 ? `${whole.toString()}.${frac}` : whole.toString();
+}
+registerAdapter("decibel", () => new DecibelAdapter());
+export default DecibelAdapter;