@raintree-technology/perps 0.1.3 → 0.1.4

package/dist/adapters/decibel.js

@@ -15,12 +15,14 @@ const DECIBEL_DEFAULTS = {
         restUrl: "https://api.testnet.aptoslabs.com/decibel",
         wsUrl: "wss://api.testnet.aptoslabs.com/decibel/ws",
         packageAddress: "0x952535c3049e52f195f26798c2f1340d7dd5100edbe0f464e520a974d16fbe9f",
+        usdcAddress: "0xbdabb88aa9a875f3a2ebe0974e24f3ae5e57cfd17c6abdfef8a8111f43681b7e",
     },
     mainnet: {
         fullnodeUrl: "https://api.mainnet.aptoslabs.com/v1",
         restUrl: "https://api.mainnet.aptoslabs.com/decibel",
         wsUrl: "wss://api.mainnet.aptoslabs.com/decibel/ws",
-        packageAddress: "0x50ead22afd6ffd9769e3b3d6e0e64a2a350d68e8b102c4e72e33d0b8cfdfdb06",
+        packageAddress: "0xe6683d451db246750f180fb78d9b5e0a855dacba64ddf5810dffdaeb221e46bf",
+        usdcAddress: "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b",
     },
 };
 export class DecibelAdapter {
@@ -34,20 +36,20 @@ export class DecibelAdapter {
             perp: true,
             margin: true,
             crossMargin: true,
-            isolatedMargin: false,
+            isolatedMargin: true,
             stopOrders: true,
             takeProfitOrders: true,
             postOnly: true,
             reduceOnly: true,
             subaccounts: true,
-            modifyOrders: false,
+            modifyOrders: true,
             batchOrders: false,
             cancelAllAfter: false,
             publicTrades: true,
-            fundingHistory: false,
+            fundingHistory: true,
             orderHistory: true,
             mmp: false,
-            twapOrders: false,
+            twapOrders: true,
         },
         urls: {
             app: "https://app.decibel.trade",
@@ -78,6 +80,8 @@ export class DecibelAdapter {
     assetContextsByMarketAddr = new Map();
     assetContextsTimestamp = 0;
     trackedMarketAddrs = new Set();
+    depthAggregationSize = 1;
+    twapStatusById = new Map();
     tickerSubscribers = new Map();
     orderBookSubscribers = new Map();
     globalSubscribers = new Set();
@@ -92,6 +96,7 @@ export class DecibelAdapter {
         const wsUrl = config.wsUrl ?? credentials?.wsUrl ?? defaults.wsUrl;
         const fullnodeUrl = config.rpcUrl ?? credentials?.fullnodeUrl ?? defaults.fullnodeUrl;
         const packageAddress = credentials?.packageAddress ?? defaults.packageAddress;
+        const usdcAddress = credentials?.usdcAddress ?? defaults.usdcAddress;
         this.accountAddress = credentials?.accountAddress ?? credentials?.subaccountAddress ?? null;
         this.subaccountAddress = credentials?.subaccountAddress ?? credentials?.accountAddress ?? null;
         this.restClient = new DecibelRestClient(restUrl, credentials?.apiBearerToken);
@@ -111,6 +116,7 @@ export class DecibelAdapter {
             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("user_active_twaps", ({ data }) => this.handleWsActiveTwaps(data));
             this.wsFeed.on("notifications", ({ data }) => this.handleWsNotification(data));
             this.wsFeed.connect();
             // Subscribe to all_market_prices for global ticker updates
@@ -122,6 +128,7 @@ export class DecibelAdapter {
                 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(`user_active_twaps:${this.subaccountAddress}`);
                 this.wsFeed.subscribe(`notifications:${this.subaccountAddress}`);
             }
         }
@@ -142,6 +149,7 @@ export class DecibelAdapter {
                 fullnodeUrl,
                 network,
                 packageAddress,
+                usdcAddress,
                 privateKey: credentials.privateKey,
                 subaccountAddress: this.subaccountAddress,
             });
@@ -336,15 +344,21 @@ export class DecibelAdapter {
         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);
+        const hasWithdrawable = overview.usdc_cross_withdrawable_balance !== undefined ||
+            overview.usdc_isolated_withdrawable_balance !== undefined;
+        const withdrawable = parseNumber(overview.usdc_cross_withdrawable_balance) +
+            parseNumber(overview.usdc_isolated_withdrawable_balance);
+        const derivedLocked = Math.max(0, totalCollateral - equity);
+        const available = hasWithdrawable ? Math.max(0, withdrawable) : Math.max(0, equity - derivedLocked);
+        const locked = Math.max(0, equity - available);
         return [
             {
                 asset: "USD",
                 total: equity.toString(),
-                available: Math.max(0, equity - marginUsed).toString(),
-                locked: marginUsed.toString(),
+                available: available.toString(),
+                locked: locked.toString(),
                 unrealizedPnl: unrealizedPnl.toString(),
-                marginUsed: marginUsed.toString(),
+                marginUsed: locked.toString(),
             },
         ];
     }
@@ -483,8 +497,68 @@ export class DecibelAdapter {
     // --------------------------------------------------------------------------
     // Advanced Trading
     // --------------------------------------------------------------------------
-    async modifyOrder(_params) {
-        throw new Error("Decibel does not support order modification. Cancel and replace instead.");
+    async modifyOrder(params) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        const meta = this.requireMarket(params.market);
+        const existing = await this.getOrder(params.orderId);
+        if (!existing) {
+            throw new Error(`Order ${params.orderId} not found on Decibel`);
+        }
+        if (existing.type === "market") {
+            throw new Error("Decibel cannot modify filled/market orders");
+        }
+        const side = existing.side === "long" ? "buy" : "sell";
+        const sizeUnits = parseNumber(params.size ?? existing.size);
+        const price = parseNumber(params.price ?? existing.price);
+        if (!Number.isFinite(price) || price <= 0) {
+            throw new Error("Order price is required for Decibel order modification");
+        }
+        const timeInForce = existing.postOnly ? 1 : 0;
+        let stopPrice;
+        let tpTriggerPrice;
+        let tpLimitPrice;
+        let slTriggerPrice;
+        let slLimitPrice;
+        if (existing.type === "stop" || existing.type === "stop_limit") {
+            stopPrice = parseNumber(params.triggerPrice ?? existing.triggerPrice ?? existing.price);
+            if (existing.type === "stop_limit") {
+                slTriggerPrice = stopPrice;
+                slLimitPrice = price;
+            }
+        }
+        if (existing.type === "take_profit") {
+            tpTriggerPrice = parseNumber(params.triggerPrice ?? existing.triggerPrice);
+            tpLimitPrice = price;
+        }
+        const normalizedOrderId = this.normalizeTwapLookupId(params.orderId) ?? params.orderId;
+        const hasNumericOrderId = /^\d+$/.test(normalizedOrderId);
+        const txHash = await this.orderManager.updateOrder({
+            market: meta,
+            orderId: hasNumericOrderId ? normalizedOrderId : undefined,
+            clientOrderId: hasNumericOrderId ? undefined : normalizedOrderId,
+            side,
+            price,
+            sizeUnits,
+            timeInForce,
+            reduceOnly: existing.reduceOnly,
+            stopPrice,
+            tpTriggerPrice,
+            tpLimitPrice,
+            slTriggerPrice,
+            slLimitPrice,
+        });
+        const lookupId = hasNumericOrderId
+            ? normalizedOrderId
+            : existing.id;
+        for (let attempt = 0; attempt < 5; attempt++) {
+            const updated = await this.getOrder(lookupId);
+            if (updated) {
+                return updated;
+            }
+            await sleep(250);
+        }
+        throw new Error(`Decibel order updated (tx ${txHash}) but updated state is not yet queryable`);
     }
     async batchPlaceOrders(paramsList) {
         const results = [];
@@ -505,9 +579,6 @@ export class DecibelAdapter {
         }
         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();
@@ -521,9 +592,34 @@ export class DecibelAdapter {
         }
         return orders;
     }
-    async getFundingHistory(_market, _limit) {
-        // Decibel does not expose a funding payment history endpoint
-        return [];
+    async getFundingHistory(market, limit = 100) {
+        this.ensureConnected();
+        this.ensureAccountReadAuth();
+        const maxRows = Math.max(1, Math.min(limit, 500));
+        const targetMarket = market ? this.requireMarket(market) : null;
+        const rows = await this.restClient.getFundingHistory(this.accountAddress, maxRows, 0);
+        return rows
+            .filter((row) => {
+            if (!targetMarket)
+                return true;
+            const marketRaw = row.market ?? "";
+            if (marketRaw === targetMarket.marketAddr)
+                return true;
+            return this.resolveMarketSymbol(marketRaw) === targetMarket.symbol;
+        })
+            .map((row) => {
+            const amountRaw = parseNumber(row.realized_funding_amount);
+            const amount = row.is_funding_positive ? Math.abs(amountRaw) : -Math.abs(amountRaw);
+            const size = Math.abs(parseNumber(row.size));
+            const rate = size > 0 ? amount / size : 0;
+            const marketSymbol = this.resolveMarketSymbol(row.market) ?? this.normalizeSymbol(row.market);
+            return {
+                market: marketSymbol,
+                amount: amount.toString(),
+                rate: rate.toString(),
+                timestamp: parseNumber(row.transaction_unix_ms) || Date.now(),
+            };
+        });
     }
     async getPublicTrades(market, limit = 100) {
         this.ensureConnected();
@@ -544,34 +640,115 @@ export class DecibelAdapter {
         });
     }
     // --------------------------------------------------------------------------
-    // 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 placeTWAP(params) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        const meta = this.requireMarket(params.market);
+        const sizeUnits = parseNumber(params.size);
+        if (!Number.isFinite(sizeUnits) || sizeUnits <= 0) {
+            throw new Error("TWAP size must be a positive number");
+        }
+        if (!Number.isFinite(params.durationMs) || params.durationMs <= 0) {
+            throw new Error("TWAP durationMs must be a positive number");
+        }
+        const requestedIntervalMs = params.intervalMs ?? Math.min(30_000, Math.max(1_000, Math.floor(params.durationMs / 10)));
+        const normalizedIntervalMs = Math.min(params.durationMs, Math.max(1_000, requestedIntervalMs));
+        const twapFrequencySeconds = Math.max(1, Math.floor(normalizedIntervalMs / 1_000));
+        const twapDurationSeconds = Math.max(1, Math.floor(params.durationMs / 1_000));
+        const side = params.side === "long" ? "buy" : "sell";
+        const clientOrderId = `perps-twap-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const submission = await this.orderManager.placeTwapOrder({
+            market: meta,
+            side,
+            sizeUnits,
+            reduceOnly: false,
+            clientOrderId,
+            twapFrequencySeconds,
+            twapDurationSeconds,
+        });
+        if (this.accountAddress && this.config?.credentials?.apiBearerToken) {
+            const lookupIds = [submission.orderId, clientOrderId].filter((value) => typeof value === "string" && value.length > 0);
+            for (let attempt = 0; attempt < 4; attempt++) {
+                for (const lookupId of lookupIds) {
+                    const status = await this.getTWAPStatus(lookupId);
+                    if (status) {
+                        return status;
+                    }
+                }
+                await sleep(250);
+            }
+        }
+        if (submission.orderId) {
+            return {
+                id: submission.orderId,
+                market: meta.symbol,
+                side: params.side,
+                totalSize: params.size,
+                executedSize: "0",
+                remainingSize: params.size,
+                status: "active",
+                startTime: Date.now(),
+                endTime: Date.now() + params.durationMs,
+            };
+        }
+        throw new Error(`Decibel TWAP submitted (${submission.txHash}) but no native order id/status was returned yet`);
     }
-    async cancelTWAP(_twapId) {
-        throw new Error("Decibel does not support TWAP orders");
+    async cancelTWAP(twapId) {
+        this.ensureConnected();
+        this.ensureOrderManager();
+        const status = await this.getTWAPStatus(twapId);
+        if (!status) {
+            return false;
+        }
+        const orderId = this.normalizeTwapLookupId(status.id);
+        if (!orderId) {
+            throw new Error(`Unable to resolve a cancellable TWAP order id from '${twapId}'`);
+        }
+        const market = this.requireMarket(status.market);
+        try {
+            await this.orderManager.cancelTwapOrder(orderId, market.marketAddr);
+            const updated = {
+                ...status,
+                status: "cancelled",
+            };
+            this.cacheTwapStatus(updated, [twapId, status.id]);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    async getTWAPStatus(_twapId) {
-        throw new Error("Decibel does not support TWAP orders");
+    async getTWAPStatus(twapId) {
+        this.ensureConnected();
+        const normalizedLookupId = this.normalizeTwapLookupId(twapId) ?? twapId;
+        const cached = this.twapStatusById.get(normalizedLookupId) ?? this.twapStatusById.get(twapId);
+        if (cached)
+            return cached;
+        if (!this.accountAddress || !this.config?.credentials?.apiBearerToken) {
+            return null;
+        }
+        const activeRows = await this.restClient.getActiveTwaps(this.accountAddress, 200);
+        const activeStatus = this.findAndCacheTwap(activeRows, normalizedLookupId);
+        if (activeStatus) {
+            return activeStatus;
+        }
+        const historyRows = await this.restClient.getTwapHistory(this.accountAddress, 200, 0);
+        return this.findAndCacheTwap(historyRows, normalizedLookupId);
     }
     // --------------------------------------------------------------------------
     // Margin Management
     // --------------------------------------------------------------------------
     async updateIsolatedMargin(_market, _amount) {
-        throw new Error("Decibel does not support isolated margin adjustment");
+        this.ensureConnected();
+        this.ensureOrderManager();
+        const meta = this.requireMarket(_market);
+        const amount = parseNumber(_amount);
+        if (!Number.isFinite(amount) || amount === 0) {
+            throw new Error("Decibel isolated margin update requires a non-zero amount");
+        }
+        await this.orderManager.updateIsolatedPositionMargin(meta.marketAddr, amount);
     }
     subscribe(callbacks) {
         this.globalSubscribers.add(callbacks);
@@ -584,7 +761,7 @@ export class DecibelAdapter {
     subscribeOrderBook(market, callback) {
         const meta = this.requireMarket(market);
         this.trackMarket(meta.marketAddr);
-        this.wsFeed?.subscribe(`depth:${meta.marketAddr}`);
+        this.wsFeed?.subscribe(`depth:${meta.marketAddr}:${this.depthAggregationSize}`);
         if (!this.orderBookSubscribers.has(meta.symbol)) {
             this.orderBookSubscribers.set(meta.symbol, new Set());
         }
@@ -657,21 +834,30 @@ export class DecibelAdapter {
     handleWsAccountOverview(data) {
         if (!isRecord(data))
             return;
+        const overviewPayload = isRecord(data.account_overview) ? data.account_overview : data;
         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);
+                const equity = parseNumber(toNumericInput(overviewPayload.equity) ?? toNumericInput(overviewPayload.perp_equity_balance));
+                const totalCollateral = parseNumber(toNumericInput(overviewPayload.total_collateral) ?? toNumericInput(overviewPayload.total_margin));
+                const unrealizedPnl = parseNumber(toNumericInput(overviewPayload.unrealized_pnl));
+                const hasWithdrawable = overviewPayload.usdc_cross_withdrawable_balance !== undefined ||
+                    overviewPayload.usdc_isolated_withdrawable_balance !== undefined;
+                const withdrawable = parseNumber(toNumericInput(overviewPayload.usdc_cross_withdrawable_balance)) +
+                    parseNumber(toNumericInput(overviewPayload.usdc_isolated_withdrawable_balance));
+                const derivedLocked = Math.max(0, totalCollateral - equity);
+                const available = hasWithdrawable
+                    ? Math.max(0, withdrawable)
+                    : Math.max(0, equity - derivedLocked);
+                const locked = Math.max(0, equity - available);
                 callbacks.onBalances([{
                         asset: "USD",
                         total: equity.toString(),
-                        available: Math.max(0, equity - marginUsed).toString(),
-                        locked: marginUsed.toString(),
+                        available: available.toString(),
+                        locked: locked.toString(),
                         unrealizedPnl: unrealizedPnl.toString(),
-                        marginUsed: marginUsed.toString(),
+                        marginUsed: locked.toString(),
                     }]);
             }
             catch (err) {
@@ -751,15 +937,65 @@ export class DecibelAdapter {
     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);
+        // order_updates can arrive as:
+        // - { order: { ...orderFields } }
+        // - { order: { status, details, order: { ...orderFields } } }
+        // - { orders: [{ ...orderFields }] }
+        // - { ...orderFields }
+        const rows = Array.isArray(data.orders)
+            ? data.orders
+            : Array.isArray(data.items)
+                ? data.items
+                : null;
+        if (rows) {
+            const parsed = [];
+            for (const row of rows) {
+                if (!isRecord(row))
+                    continue;
+                const order = this.toOrder(row);
+                if (order)
+                    parsed.push(order);
+            }
+            if (parsed.length > 0) {
+                for (const callbacks of this.globalSubscribers) {
+                    callbacks.onOrders?.(parsed);
+                }
+            }
+            return;
+        }
+        const outerOrder = isRecord(data.order) ? data.order : null;
+        const normalizedOrder = outerOrder && isRecord(outerOrder.order) ? outerOrder.order : outerOrder ?? data;
+        const order = this.toOrder(normalizedOrder);
         if (!order)
             return;
         for (const callbacks of this.globalSubscribers) {
             callbacks.onOrders?.([order]);
         }
     }
+    handleWsActiveTwaps(data) {
+        if (!isRecord(data))
+            return;
+        const rows = Array.isArray(data.twaps)
+            ? data.twaps
+            : Array.isArray(data.data)
+                ? data.data
+                : Array.isArray(data)
+                    ? data
+                    : [];
+        for (const row of rows) {
+            if (!isRecord(row))
+                continue;
+            const twapRow = row;
+            const status = this.toTwapStatus(twapRow);
+            const aliases = [
+                twapRow.order_id,
+                twapRow.client_order_id,
+                `order:${twapRow.order_id}`,
+                `client:${twapRow.client_order_id}`,
+            ].filter((value) => typeof value === "string" && value.length > 0);
+            this.cacheTwapStatus(status, aliases);
+        }
+    }
     handleWsNotification(data) {
         if (!isRecord(data))
             return;
@@ -890,7 +1126,7 @@ export class DecibelAdapter {
             unrealizedPnl: parseNumber(row.unrealized_pnl ?? row.unrealized_funding).toString(),
             realizedPnl: "0",
             leverage: parseNumber(row.leverage ?? row.user_leverage) || 1,
-            marginType: "cross",
+            marginType: row.is_isolated ? "isolated" : "cross",
             margin: "0",
             timestamp: Date.now(),
         };
@@ -943,6 +1179,83 @@ export class DecibelAdapter {
             ...(orderId ? { orderId } : {}),
         };
     }
+    toTwapStatus(row) {
+        const totalSize = Math.max(0, parseNumber(row.orig_size));
+        const remainingSize = Math.max(0, parseNumber(row.remaining_size));
+        const executedSize = Math.max(0, totalSize - remainingSize);
+        const startTime = parseNumber(row.start_unix_ms) || parseNumber(row.transaction_unix_ms) || Date.now();
+        const durationMs = Math.max(0, parseNumber(row.duration_s) * 1_000);
+        const endTime = durationMs > 0 ? startTime + durationMs : startTime;
+        const market = this.resolveMarketSymbol(row.market) ?? this.normalizeSymbol(row.market);
+        return {
+            id: row.order_id || row.client_order_id || `twap-${startTime}`,
+            market,
+            side: row.is_buy ? "long" : "short",
+            totalSize: totalSize.toString(),
+            executedSize: executedSize.toString(),
+            remainingSize: remainingSize.toString(),
+            status: this.mapTwapState(row.status),
+            startTime,
+            endTime,
+        };
+    }
+    mapTwapState(status) {
+        const normalized = status.toLowerCase();
+        if (normalized.includes("cancel"))
+            return "cancelled";
+        if (normalized.includes("finish") || normalized.includes("complete"))
+            return "completed";
+        return "active";
+    }
+    cacheTwapStatus(status, aliases = []) {
+        const keys = new Set([status.id, ...aliases]);
+        for (const key of keys) {
+            if (!key)
+                continue;
+            this.twapStatusById.set(key, status);
+            const normalized = this.normalizeTwapLookupId(key);
+            if (normalized) {
+                this.twapStatusById.set(normalized, status);
+            }
+        }
+    }
+    findAndCacheTwap(rows, lookupId) {
+        for (const row of rows) {
+            const status = this.toTwapStatus(row);
+            const aliases = [row.order_id, row.client_order_id, `order:${row.order_id}`, `client:${row.client_order_id}`]
+                .filter((value) => typeof value === "string" && value.length > 0);
+            this.cacheTwapStatus(status, aliases);
+            for (const alias of aliases) {
+                if (this.isMatchingTwapLookupId(alias, lookupId)) {
+                    return status;
+                }
+            }
+            if (this.isMatchingTwapLookupId(status.id, lookupId)) {
+                return status;
+            }
+        }
+        return null;
+    }
+    normalizeTwapLookupId(twapId) {
+        const value = twapId.trim();
+        if (!value)
+            return null;
+        for (const prefix of ["client:", "order:", "twap:"]) {
+            if (value.startsWith(prefix) && value.length > prefix.length) {
+                return value.slice(prefix.length);
+            }
+        }
+        return value;
+    }
+    isMatchingTwapLookupId(candidate, lookupId) {
+        const normalizedCandidate = this.normalizeTwapLookupId(candidate);
+        const normalizedLookup = this.normalizeTwapLookupId(lookupId);
+        if (candidate === lookupId)
+            return true;
+        if (!normalizedCandidate || !normalizedLookup)
+            return false;
+        return normalizedCandidate === normalizedLookup;
+    }
     resolveMarketSymbol(input) {
         const raw = input.trim();
         if (!raw)
@@ -1027,7 +1340,7 @@ export class DecibelAdapter {
             return;
         this.trackedMarketAddrs.add(marketAddr);
         this.wsFeed?.subscribe(`market_price:${marketAddr}`);
-        this.wsFeed?.subscribe(`depth:${marketAddr}`);
+        this.wsFeed?.subscribe(`depth:${marketAddr}:${this.depthAggregationSize}`);
         this.wsFeed?.subscribe(`trades:${marketAddr}`);
     }
     handleWsPrice(marketAddr, data) {
@@ -1226,7 +1539,7 @@ export class DecibelAdapter {
     }
 }
 function parseNumber(value) {
-    if (value === undefined)
+    if (value === undefined || value === null)
         return 0;
     const num = Number(value);
     return Number.isFinite(num) ? num : 0;
@@ -1249,6 +1562,11 @@ function toNumericInput(value) {
     }
     return undefined;
 }
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 function coerceWsPricePayload(marketAddr, data) {
     const payload = isRecord(data) ? data : {};
     const market = typeof payload.market === "string" ? payload.market : marketAddr;
@@ -1258,6 +1576,9 @@ function coerceWsPricePayload(marketAddr, data) {
         mark_px: toNumericInput(payload.mark_px) ?? 0,
         mid_px: toNumericInput(payload.mid_px) ?? 0,
         funding_rate_bps: toNumericInput(payload.funding_rate_bps) ?? 0,
+        is_funding_positive: typeof payload.is_funding_positive === "boolean"
+            ? payload.is_funding_positive
+            : undefined,
         open_interest: toNumericInput(payload.open_interest) ?? 0,
         transaction_unix_ms: toNumericInput(payload.transaction_unix_ms),
     };

package/dist/adapters/hyperliquid.d.ts

@@ -2,7 +2,7 @@
  * Hyperliquid Adapter
  * Implements PerpDEXAdapter interface for Hyperliquid DEX
  */
-import { type PerpDEXAdapter, type ExchangeInfo, type ExchangeConfig, type Market, type Ticker, type OrderBook, type FundingRate, type Position, type Order, type Balance, type Trade, type OrderParams, type CancelOrderParams, type ModifyOrderParams, type FundingPayment, type PublicTrade, type SubscriptionCallbacks, type Unsubscribe, type MarginType, type MMPConfig, type MMPStatus, type TWAPParams, type TWAPStatus } from "./interface.js";
+import { type PerpDEXAdapter, type ExchangeInfo, type ExchangeConfig, type Market, type Ticker, type OrderBook, type FundingRate, type Position, type Order, type Balance, type Trade, type OrderParams, type CancelOrderParams, type ModifyOrderParams, type PublicTrade, type SubscriptionCallbacks, type Unsubscribe, type MarginType, type TWAPParams, type TWAPStatus } from "./interface.js";
 export declare class HyperliquidAdapter implements PerpDEXAdapter {
     readonly info: ExchangeInfo;
     private httpTransport;
@@ -40,14 +40,9 @@ export declare class HyperliquidAdapter implements PerpDEXAdapter {
     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;

package/dist/adapters/hyperliquid.js

@@ -555,9 +555,6 @@ export class HyperliquidAdapter {
         }
         return orders;
     }
-    async getFundingHistory(_market, _limit) {
-        throw new Error("Hyperliquid does not expose a per-user funding history endpoint");
-    }
     async getPublicTrades(market, limit = 100) {
         this.ensureConnected();
         const coin = market.toUpperCase().replace("-PERP", "");
@@ -572,18 +569,6 @@ export class HyperliquidAdapter {
         }));
     }
     // --------------------------------------------------------------------------
-    // Market Maker Protection
-    // --------------------------------------------------------------------------
-    async setMMP(_config) {
-        throw new Error("Hyperliquid does not support Market Maker Protection (MMP)");
-    }
-    async getMMP(_market) {
-        throw new Error("Hyperliquid does not support Market Maker Protection (MMP)");
-    }
-    async resetMMP(_market) {
-        throw new Error("Hyperliquid does not support Market Maker Protection (MMP)");
-    }
-    // --------------------------------------------------------------------------
     // TWAP Orders
     // --------------------------------------------------------------------------
     async placeTWAP(params) {
@@ -622,9 +607,6 @@ export class HyperliquidAdapter {
             return false;
         }
     }
-    async getTWAPStatus(_twapId) {
-        throw new Error("Hyperliquid does not expose a TWAP status query endpoint");
-    }
     // --------------------------------------------------------------------------
     // Margin Management
     // --------------------------------------------------------------------------