@raintree-technology/perps 0.1.0

package/dist/adapters/paradex.js

@@ -0,0 +1,862 @@
+/**
+ * Paradex Adapter
+ * Implements PerpDEXAdapter interface for Paradex DEX (Starknet L2)
+ *
+ * API Docs: https://docs.paradex.trade/
+ * Base URL: https://api.prod.paradex.trade/v1
+ */
+import { ec, shortString, typedData as starkTypedData } from "starknet";
+import { registerAdapter, } from "./interface.js";
+import { fetchWithTimeout } from "../lib/fetch.js";
+import { createLogger } from "../lib/logger.js";
+import { FUNDING_INTERVAL_HOURS } from "../lib/constants.js";
+import { pickUnknown, pickObject, pickString, pickNumber, pickBoolean, toTimestampMs, decimalToScaled } from "./utils.js";
+const log = createLogger("paradex");
+const SEVEN_DAYS_SECONDS = 7 * 24 * 60 * 60;
+export class ParadexAdapter {
+    info = {
+        id: "paradex",
+        name: "Paradex",
+        type: "dex",
+        chains: ["starknet"],
+        features: {
+            spot: false,
+            perp: true,
+            margin: true,
+            crossMargin: true,
+            isolatedMargin: true,
+            stopOrders: true,
+            takeProfitOrders: true,
+            postOnly: true,
+            reduceOnly: true,
+            subaccounts: false,
+            modifyOrders: true,
+            batchOrders: true,
+            cancelAllAfter: false,
+            publicTrades: true,
+            fundingHistory: true,
+            orderHistory: true,
+            mmp: false,
+            twapOrders: false,
+        },
+        urls: {
+            app: "https://app.paradex.trade",
+            api: "https://api.prod.paradex.trade/v1",
+            docs: "https://docs.paradex.trade",
+            testnet: "https://api.testnet.paradex.trade/v1",
+        },
+        implementation: {
+            marketData: "full",
+            authenticatedReads: "full",
+            orderLifecycle: "full",
+            orderCancellation: "full",
+            subscriptions: "full",
+            advancedTrading: "full",
+        },
+    };
+    baseUrl = "https://api.prod.paradex.trade/v1";
+    config = null;
+    connected = false;
+    marketsCache = null;
+    jwtToken = null;
+    starknetChainId = null;
+    subscriptionTimers = new Set();
+    async connect(config) {
+        this.config = config;
+        const credentialsUrl = config.credentials?.restUrl;
+        const network = config.credentials?.network;
+        if (credentialsUrl) {
+            this.baseUrl = credentialsUrl.replace(/\/$/, "");
+        }
+        else if (network === "testnet" || (network !== "mainnet" && config.testnet)) {
+            this.baseUrl = "https://api.testnet.paradex.trade/v1";
+        }
+        else {
+            this.baseUrl = "https://api.prod.paradex.trade/v1";
+        }
+        this.jwtToken = config.credentials?.apiBearerToken ?? null;
+        this.starknetChainId =
+            config.credentials?.paradexChainId && config.credentials.paradexChainId.trim().length > 0
+                ? this.toChainIdFelt(config.credentials.paradexChainId)
+                : null;
+        await this.fetchMarkets();
+        this.connected = true;
+    }
+    async disconnect() {
+        for (const timer of this.subscriptionTimers) {
+            clearInterval(timer);
+        }
+        this.subscriptionTimers.clear();
+        this.config = null;
+        this.marketsCache = null;
+        this.jwtToken = null;
+        this.starknetChainId = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    // --------------------------------------------------------------------------
+    // Private API helpers
+    // --------------------------------------------------------------------------
+    async fetch(endpoint, options) {
+        const url = `${this.baseUrl}${endpoint}`;
+        log.debug(`Fetching ${endpoint}`);
+        return fetchWithTimeout(url, options);
+    }
+    async fetchPrivate(endpoint, options) {
+        const token = await this.ensureJwtToken();
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            ...(options?.headers ?? {}),
+        };
+        return this.fetch(endpoint, {
+            ...options,
+            headers,
+        });
+    }
+    async ensureJwtToken() {
+        if (this.jwtToken)
+            return this.jwtToken;
+        const account = this.config?.credentials?.paradexAccount ?? this.config?.credentials?.accountAddress;
+        const privateKey = this.config?.credentials?.privateKey;
+        if (!account || !privateKey) {
+            throw new Error("Paradex private endpoints require PARADEX_API_BEARER_TOKEN or PARADEX_ACCOUNT_ADDRESS + PARADEX_PRIVATE_KEY");
+        }
+        this.jwtToken = await this.authenticate(account, privateKey);
+        return this.jwtToken;
+    }
+    async authenticate(accountAddress, privateKey) {
+        const chainId = await this.getStarkChainId();
+        const parsePayload = async (response) => {
+            const raw = (await response.text()).trim();
+            if (!raw) {
+                return { raw };
+            }
+            try {
+                const parsed = JSON.parse(raw);
+                return { raw, json: parsed };
+            }
+            catch {
+                return { raw };
+            }
+        };
+        const describeError = (prefix, status, payload) => {
+            const detail = (typeof payload.json?.message === "string" && payload.json.message.trim()) ||
+                (typeof payload.json?.error === "string" && payload.json.error.trim()) ||
+                payload.raw;
+            return `${prefix} HTTP ${status}${detail ? `: ${detail}` : ""}`;
+        };
+        const signedPost = async (typedPath, endpointPath, extraHeaders = {}) => {
+            const timestamp = Math.floor(Date.now() / 1000);
+            const expiration = timestamp + SEVEN_DAYS_SECONDS;
+            const typed = {
+                domain: {
+                    name: "Paradex",
+                    chainId,
+                    version: "1",
+                },
+                primaryType: "Request",
+                types: {
+                    StarkNetDomain: [
+                        { name: "name", type: "felt" },
+                        { name: "chainId", type: "felt" },
+                        { name: "version", type: "felt" },
+                    ],
+                    Request: [
+                        { name: "method", type: "felt" },
+                        { name: "path", type: "felt" },
+                        { name: "body", type: "felt" },
+                        { name: "timestamp", type: "felt" },
+                        { name: "expiration", type: "felt" },
+                    ],
+                },
+                message: {
+                    method: "POST",
+                    path: typedPath,
+                    body: "",
+                    timestamp,
+                    expiration,
+                },
+            };
+            const messageHash = starkTypedData.getMessageHash(typed, accountAddress);
+            const signature = ec.starkCurve.sign(messageHash, privateKey);
+            const signatureValue = JSON.stringify([signature.r.toString(), signature.s.toString()]);
+            return fetch(`${this.baseUrl}${endpointPath}`, {
+                method: "POST",
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                    "PARADEX-STARKNET-ACCOUNT": accountAddress,
+                    "PARADEX-STARKNET-SIGNATURE": signatureValue,
+                    "PARADEX-TIMESTAMP": String(timestamp),
+                    "PARADEX-SIGNATURE-EXPIRATION": String(expiration),
+                    ...extraHeaders,
+                },
+                body: JSON.stringify({}),
+            });
+        };
+        let authResponse = await signedPost("/v1/auth", "/auth");
+        let authPayload = await parsePayload(authResponse);
+        if (!authResponse.ok && authPayload.raw.includes("NOT_ONBOARDED")) {
+            const ethereumAccount = this.config?.credentials?.paradexEthereumAccount;
+            const onboardingHeaders = {};
+            if (ethereumAccount) {
+                onboardingHeaders["PARADEX-ETHEREUM-ACCOUNT"] = ethereumAccount;
+            }
+            const onboardingResponse = await signedPost("/v1/onboarding", "/onboarding", onboardingHeaders);
+            const onboardingPayload = await parsePayload(onboardingResponse);
+            if (!onboardingResponse.ok) {
+                throw new Error(describeError("Paradex onboarding", onboardingResponse.status, onboardingPayload));
+            }
+            authResponse = await signedPost("/v1/auth", "/auth");
+            authPayload = await parsePayload(authResponse);
+        }
+        if (!authResponse.ok) {
+            throw new Error(describeError("Paradex authentication", authResponse.status, authPayload));
+        }
+        const token = (typeof authPayload.json?.jwt_token === "string" && authPayload.json.jwt_token.trim()) ||
+            undefined;
+        if (!token) {
+            throw new Error("Paradex authentication did not return jwt_token");
+        }
+        return token;
+    }
+    async fetchMarkets() {
+        if (this.marketsCache)
+            return this.marketsCache;
+        const response = await this.fetch("/markets");
+        this.marketsCache = response.results.filter((m) => m.asset_kind === "PERP");
+        return this.marketsCache;
+    }
+    async getStarkChainId() {
+        if (this.starknetChainId)
+            return this.starknetChainId;
+        const config = await this.fetch("/system/config");
+        const chainIdRaw = config.starknet_chain_id;
+        if (!chainIdRaw) {
+            throw new Error("Paradex system config missing starknet_chain_id");
+        }
+        this.starknetChainId = this.toChainIdFelt(chainIdRaw);
+        return this.starknetChainId;
+    }
+    toChainIdFelt(value) {
+        const trimmed = value.trim();
+        if (trimmed.startsWith("0x"))
+            return trimmed;
+        return shortString.encodeShortString(trimmed);
+    }
+    // --------------------------------------------------------------------------
+    // Public Market Data
+    // --------------------------------------------------------------------------
+    async getMarkets() {
+        const markets = await this.fetchMarkets();
+        return markets.map((m) => {
+            const imfBase = parseFloat(m.delta1_cross_margin_params.imf_base) || 0.1;
+            const maxLeverage = Math.floor(1 / imfBase);
+            return {
+                symbol: m.symbol,
+                baseAsset: m.base_currency,
+                quoteAsset: m.quote_currency,
+                type: "perp",
+                maxLeverage,
+                minSize: m.order_size_increment,
+                tickSize: m.price_tick_size,
+                fundingInterval: FUNDING_INTERVAL_HOURS,
+                isActive: true,
+            };
+        });
+    }
+    async getMarket(symbol) {
+        const markets = await this.getMarkets();
+        const normalized = this.normalizeSymbol(symbol);
+        return markets.find((m) => m.symbol === normalized) ?? null;
+    }
+    async getTicker(market) {
+        const symbol = this.normalizeSymbol(market);
+        const response = await this.fetch(`/markets/summary?market=${encodeURIComponent(symbol)}`);
+        if (!response.results || response.results.length === 0) {
+            throw new Error(`Market ${market} not found`);
+        }
+        const summary = response.results[0];
+        // Get high/low from summary if available, otherwise try candlesticks
+        let high24h = summary.high_24h ?? "0";
+        let low24h = summary.low_24h ?? "0";
+        if (high24h === "0" || low24h === "0") {
+            try {
+                const now = Math.floor(Date.now() / 1000);
+                const oneDayAgo = now - 86_400;
+                const candles = await this.fetch(`/markets/klines?market=${encodeURIComponent(symbol)}&resolution=1D&start_at=${oneDayAgo}&end_at=${now}`);
+                if (candles.results?.length > 0) {
+                    const candle = candles.results[candles.results.length - 1];
+                    if (candle.high)
+                        high24h = candle.high;
+                    if (candle.low)
+                        low24h = candle.low;
+                }
+            }
+            catch {
+                // Candlestick endpoint may not be available for all markets
+            }
+        }
+        return {
+            market: symbol,
+            lastPrice: summary.last_traded_price,
+            markPrice: summary.mark_price,
+            indexPrice: summary.underlying_price,
+            bid: summary.bid,
+            ask: summary.ask,
+            volume24h: summary.volume_24h,
+            change24h: (parseFloat(summary.price_change_rate_24h) * 100).toFixed(2),
+            high24h,
+            low24h,
+            openInterest: summary.open_interest,
+            fundingRate: summary.funding_rate,
+            timestamp: summary.created_at,
+        };
+    }
+    async getTickers() {
+        const response = await this.fetch("/markets/summary?market=ALL");
+        return response.results.map((summary) => ({
+            market: summary.symbol,
+            lastPrice: summary.last_traded_price,
+            markPrice: summary.mark_price,
+            indexPrice: summary.underlying_price,
+            bid: summary.bid,
+            ask: summary.ask,
+            volume24h: summary.volume_24h,
+            change24h: (parseFloat(summary.price_change_rate_24h) * 100).toFixed(2),
+            high24h: summary.high_24h ?? "0",
+            low24h: summary.low_24h ?? "0",
+            openInterest: summary.open_interest,
+            fundingRate: summary.funding_rate,
+            timestamp: summary.created_at,
+        }));
+    }
+    async getOrderBook(market, depth = 20) {
+        const symbol = this.normalizeSymbol(market);
+        const response = await this.fetch(`/orderbook/${encodeURIComponent(symbol)}`);
+        return {
+            market: symbol,
+            bids: (response.bids ?? []).slice(0, depth).map(([price, size]) => ({ price, size })),
+            asks: (response.asks ?? []).slice(0, depth).map(([price, size]) => ({ price, size })),
+            timestamp: response.last_updated_at ?? Date.now(),
+        };
+    }
+    async getFundingRate(market) {
+        const symbol = this.normalizeSymbol(market);
+        const response = await this.fetch(`/markets/summary?market=${encodeURIComponent(symbol)}`);
+        if (!response.results || response.results.length === 0) {
+            return {
+                market: symbol,
+                rate: "0",
+                nextFundingTime: Date.now() + FUNDING_INTERVAL_HOURS * 3600000,
+                timestamp: Date.now(),
+            };
+        }
+        const summary = response.results[0];
+        return {
+            market: symbol,
+            rate: summary.funding_rate,
+            nextFundingTime: summary.next_funding_time ?? Date.now() + FUNDING_INTERVAL_HOURS * 3600000,
+            timestamp: summary.created_at,
+        };
+    }
+    async getFundingRates() {
+        // Use the ALL summary endpoint to get funding rates for every market
+        const response = await this.fetch("/markets/summary?market=ALL");
+        return response.results
+            .filter((s) => s.funding_rate && s.funding_rate !== "0")
+            .map((s) => ({
+            market: s.symbol,
+            rate: s.funding_rate,
+            nextFundingTime: s.next_funding_time ?? Date.now() + FUNDING_INTERVAL_HOURS * 3600000,
+            timestamp: s.created_at,
+        }));
+    }
+    // --------------------------------------------------------------------------
+    // Account Data (requires auth)
+    // --------------------------------------------------------------------------
+    async getPositions() {
+        const response = await this.fetchPrivate("/positions");
+        const rows = response.results ?? [];
+        return rows
+            .map((row) => {
+            const market = this.normalizeSymbol(pickString(row, ["market", "symbol"]) ?? "");
+            if (!market)
+                return null;
+            const size = pickNumber(row, ["size", "position_size", "qty"], 0);
+            if (size === 0)
+                return null;
+            const sideRaw = pickString(row, ["side"])?.toLowerCase();
+            const side = sideRaw === "sell" || sideRaw === "short" || size < 0 ? "short" : "long";
+            return {
+                market,
+                side,
+                size: Math.abs(size).toString(),
+                entryPrice: pickString(row, ["avg_entry_price", "entry_price", "average_entry_price"]) ?? "0",
+                markPrice: pickString(row, ["mark_price", "last_price"]) ?? "0",
+                liquidationPrice: pickString(row, ["liquidation_price", "liq_price"]) ?? null,
+                unrealizedPnl: pickString(row, ["unrealized_pnl", "upnl"]) ?? "0",
+                realizedPnl: pickString(row, ["realized_pnl", "rpnl"]) ?? "0",
+                leverage: pickNumber(row, ["leverage"], 1),
+                marginType: pickString(row, ["margin_type"])?.toLowerCase() || "cross",
+                margin: pickString(row, ["position_margin", "initial_margin"]) ?? "0",
+                timestamp: toTimestampMs(pickUnknown(row, ["updated_at", "created_at"]), Date.now()),
+            };
+        })
+            .filter((row) => row !== null);
+    }
+    async getPosition(market) {
+        const positions = await this.getPositions();
+        const symbol = this.normalizeSymbol(market);
+        return positions.find((p) => p.market === symbol) ?? null;
+    }
+    async getOrders(market) {
+        const suffix = market ? `?market=${encodeURIComponent(this.normalizeSymbol(market))}` : "";
+        const response = await this.fetchPrivate(`/orders${suffix}`);
+        return (response.results ?? [])
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+    }
+    async getOrder(orderId) {
+        const response = await this.fetchPrivate(`/orders/${encodeURIComponent(orderId)}`);
+        const mapped = this.toOrder(response);
+        if (mapped)
+            return mapped;
+        const orders = await this.getOrders();
+        return orders.find((o) => o.id === orderId) ?? null;
+    }
+    async getBalances() {
+        const account = await this.fetchPrivate("/account");
+        const accountValue = pickNumber(account, ["account_value"], 0);
+        const freeCollateral = pickNumber(account, ["free_collateral"], accountValue);
+        const unrealizedPnl = pickNumber(account, ["unrealized_pnl"], 0);
+        const marginUsed = Math.max(0, accountValue - freeCollateral);
+        return [
+            {
+                asset: "USDC",
+                total: accountValue.toString(),
+                available: freeCollateral.toString(),
+                locked: marginUsed.toString(),
+                unrealizedPnl: unrealizedPnl.toString(),
+                marginUsed: marginUsed.toString(),
+            },
+        ];
+    }
+    async getTrades(market, limit = 100) {
+        const params = new URLSearchParams();
+        if (market)
+            params.set("market", this.normalizeSymbol(market));
+        params.set("page_size", String(Math.max(1, Math.min(limit, 500))));
+        const response = await this.fetchPrivate(`/fills?${params.toString()}`);
+        return (response.results ?? [])
+            .map((row) => {
+            const symbol = this.normalizeSymbol(pickString(row, ["market", "symbol"]) ?? "");
+            if (!symbol)
+                return null;
+            const sideRaw = pickString(row, ["side"])?.toLowerCase() ?? "buy";
+            const side = sideRaw === "sell" ? "short" : "long";
+            const orderId = pickString(row, ["order_id"]);
+            return {
+                id: pickString(row, ["id", "fill_id", "trade_id"]) ??
+                    `${symbol}-${Date.now()}`,
+                market: symbol,
+                side,
+                price: pickString(row, ["price", "fill_price"]) ?? "0",
+                size: pickString(row, ["size", "fill_size", "quantity"]) ?? "0",
+                fee: pickString(row, ["fee", "fee_paid"]) ?? "0",
+                feeAsset: pickString(row, ["fee_asset"]) ?? "USDC",
+                timestamp: toTimestampMs(pickUnknown(row, ["created_at", "timestamp"]), Date.now()),
+                ...(orderId ? { orderId } : {}),
+            };
+        })
+            .filter((row) => row !== null);
+    }
+    // --------------------------------------------------------------------------
+    // Trading
+    // --------------------------------------------------------------------------
+    async placeOrder(params) {
+        const account = this.config?.credentials?.paradexAccount ?? this.config?.credentials?.accountAddress;
+        const privateKey = this.config?.credentials?.privateKey;
+        if (!account || !privateKey) {
+            throw new Error("Paradex order placement requires PARADEX_ACCOUNT_ADDRESS and PARADEX_PRIVATE_KEY");
+        }
+        const market = this.normalizeSymbol(params.market);
+        const type = this.toParadexOrderType(params.type);
+        const side = params.side === "long" ? "BUY" : "SELL";
+        const size = params.size;
+        const price = type === "MARKET"
+            ? "0"
+            : params.price
+                ? params.price
+                : (() => {
+                    throw new Error("Price is required for non-market orders");
+                })();
+        const signatureTimestamp = Date.now();
+        const signature = await this.signOrder({
+            account,
+            privateKey,
+            market,
+            side,
+            type,
+            size,
+            price,
+            signatureTimestamp,
+        });
+        const payload = {
+            market,
+            side,
+            type,
+            size,
+            instruction: params.postOnly ? "POST_ONLY" : "GTC",
+            signature,
+            signature_timestamp: signatureTimestamp,
+            client_id: params.clientOrderId,
+            reduce_only: params.reduceOnly ?? false,
+        };
+        if (type !== "MARKET") {
+            payload.price = price;
+        }
+        const response = await this.fetchPrivate("/orders", {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+        const orderCandidate = pickObject(response, ["results.0", "data", "result"]) ?? payload;
+        const mapped = this.toOrder(orderCandidate);
+        if (mapped) {
+            return mapped;
+        }
+        return {
+            id: pickString(orderCandidate, ["id", "order_id", "client_id"]) ??
+                String(signatureTimestamp),
+            market,
+            side: params.side,
+            type: params.type,
+            size,
+            price: type === "MARKET" ? null : price,
+            filled: "0",
+            remaining: size,
+            status: "open",
+            reduceOnly: params.reduceOnly ?? false,
+            postOnly: params.postOnly ?? false,
+            timestamp: signatureTimestamp,
+            triggerPrice: params.triggerPrice,
+        };
+    }
+    async cancelOrder(params) {
+        let orderId = params.orderId;
+        if (!orderId && params.clientOrderId) {
+            const orders = await this.getOrders(params.market);
+            const match = orders.find((row) => row.id === params.clientOrderId);
+            orderId = match?.id;
+        }
+        if (!orderId) {
+            throw new Error("cancelOrder requires orderId or a resolvable clientOrderId");
+        }
+        await this.fetchPrivate(`/orders/${encodeURIComponent(orderId)}`, {
+            method: "DELETE",
+        });
+        return true;
+    }
+    async cancelAllOrders(market) {
+        const suffix = market ? `?market=${encodeURIComponent(this.normalizeSymbol(market))}` : "";
+        const response = await this.fetchPrivate(`/orders${suffix}`, {
+            method: "DELETE",
+        });
+        const explicit = pickNumber(response, ["cancelled", "count"], NaN);
+        if (Number.isFinite(explicit) && explicit >= 0) {
+            return Math.floor(explicit);
+        }
+        const results = pickUnknown(response, ["results"]);
+        if (Array.isArray(results)) {
+            return results.length;
+        }
+        return market ? 1 : 0;
+    }
+    async setLeverage(market, leverage) {
+        const symbol = this.normalizeSymbol(market);
+        await this.fetchPrivate(`/account/margin/${encodeURIComponent(symbol)}`, {
+            method: "POST",
+            body: JSON.stringify({ leverage }),
+        });
+    }
+    async setMarginType(market, type) {
+        const symbol = this.normalizeSymbol(market);
+        await this.fetchPrivate(`/account/margin/${encodeURIComponent(symbol)}`, {
+            method: "POST",
+            body: JSON.stringify({ margin_type: type.toUpperCase() }),
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Advanced Trading
+    // --------------------------------------------------------------------------
+    async modifyOrder(params) {
+        const payload = {};
+        if (params.price)
+            payload.price = params.price;
+        if (params.size)
+            payload.size = params.size;
+        if (params.triggerPrice)
+            payload.trigger_price = params.triggerPrice;
+        const response = await this.fetchPrivate(`/orders/${encodeURIComponent(params.orderId)}`, {
+            method: "PUT",
+            body: JSON.stringify(payload),
+        });
+        const orderCandidate = pickObject(response, ["results.0", "data", "result"]);
+        if (orderCandidate) {
+            const mapped = this.toOrder(orderCandidate);
+            if (mapped)
+                return mapped;
+        }
+        const order = await this.getOrder(params.orderId);
+        if (order)
+            return order;
+        throw new Error(`Failed to retrieve modified order ${params.orderId}`);
+    }
+    async batchPlaceOrders(paramsList) {
+        // Paradex supports batch via POST /orders with array body
+        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("Paradex does not support cancelAllAfter (dead man's switch)");
+    }
+    async getOrderHistory(market, limit = 100) {
+        const params = new URLSearchParams();
+        if (market)
+            params.set("market", this.normalizeSymbol(market));
+        params.set("page_size", String(Math.max(1, Math.min(limit, 500))));
+        const response = await this.fetchPrivate(`/orders/history?${params.toString()}`);
+        return (response.results ?? [])
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+    }
+    async getFundingHistory(market, limit = 100) {
+        const params = new URLSearchParams();
+        if (market)
+            params.set("market", this.normalizeSymbol(market));
+        params.set("page_size", String(Math.max(1, Math.min(limit, 500))));
+        const response = await this.fetchPrivate(`/funding/payments?${params.toString()}`);
+        return (response.results ?? []).map((row) => ({
+            market: this.normalizeSymbol(pickString(row, ["market", "symbol"]) ?? ""),
+            amount: pickString(row, ["payment", "amount", "funding_payment"]) ?? "0",
+            rate: pickString(row, ["funding_rate", "rate"]) ?? "0",
+            timestamp: toTimestampMs(pickUnknown(row, ["created_at", "timestamp"]), Date.now()),
+        }));
+    }
+    async getPublicTrades(market, limit = 100) {
+        const symbol = this.normalizeSymbol(market);
+        const response = await this.fetch(`/trades?market=${encodeURIComponent(symbol)}&page_size=${Math.min(limit, 500)}`);
+        return (response.results ?? []).map((row) => ({
+            id: pickString(row, ["id", "trade_id"]) ?? `${Date.now()}`,
+            market: symbol,
+            side: (pickString(row, ["side"])?.toLowerCase() === "sell" ? "short" : "long"),
+            price: pickString(row, ["price"]) ?? "0",
+            size: pickString(row, ["size", "amount"]) ?? "0",
+            timestamp: toTimestampMs(pickUnknown(row, ["created_at", "timestamp"]), Date.now()),
+        }));
+    }
+    // --------------------------------------------------------------------------
+    // Market Maker Protection
+    // --------------------------------------------------------------------------
+    async setMMP(_config) {
+        throw new Error("Paradex does not support Market Maker Protection (MMP)");
+    }
+    async getMMP(_market) {
+        throw new Error("Paradex does not support Market Maker Protection (MMP)");
+    }
+    async resetMMP(_market) {
+        throw new Error("Paradex does not support Market Maker Protection (MMP)");
+    }
+    // --------------------------------------------------------------------------
+    // TWAP Orders
+    // --------------------------------------------------------------------------
+    async placeTWAP(_params) {
+        throw new Error("Paradex does not support TWAP orders");
+    }
+    async cancelTWAP(_twapId) {
+        throw new Error("Paradex does not support TWAP orders");
+    }
+    async getTWAPStatus(_twapId) {
+        throw new Error("Paradex does not support TWAP orders");
+    }
+    // --------------------------------------------------------------------------
+    // Margin Management
+    // --------------------------------------------------------------------------
+    async updateIsolatedMargin(_market, _amount) {
+        throw new Error("Paradex does not support isolated margin adjustment");
+    }
+    // --------------------------------------------------------------------------
+    // Subscriptions (polling)
+    // --------------------------------------------------------------------------
+    subscribe(callbacks) {
+        const timer = setInterval(async () => {
+            try {
+                if (callbacks.onPositions)
+                    callbacks.onPositions(await this.getPositions());
+                if (callbacks.onOrders)
+                    callbacks.onOrders(await this.getOrders());
+                if (callbacks.onBalances)
+                    callbacks.onBalances(await this.getBalances());
+            }
+            catch (err) {
+                callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+        }, 3000);
+        this.subscriptionTimers.add(timer);
+        return () => {
+            clearInterval(timer);
+            this.subscriptionTimers.delete(timer);
+        };
+    }
+    subscribeOrderBook(market, callback) {
+        const symbol = this.normalizeSymbol(market);
+        const timer = setInterval(async () => {
+            try {
+                callback(await this.getOrderBook(symbol));
+            }
+            catch {
+                // Ignore transient polling errors.
+            }
+        }, 1200);
+        this.subscriptionTimers.add(timer);
+        return () => {
+            clearInterval(timer);
+            this.subscriptionTimers.delete(timer);
+        };
+    }
+    subscribeTicker(market, callback) {
+        const symbol = this.normalizeSymbol(market);
+        const timer = setInterval(async () => {
+            try {
+                callback(await this.getTicker(symbol));
+            }
+            catch {
+                // Ignore transient polling errors.
+            }
+        }, 1200);
+        this.subscriptionTimers.add(timer);
+        return () => {
+            clearInterval(timer);
+            this.subscriptionTimers.delete(timer);
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Private Helpers
+    // --------------------------------------------------------------------------
+    normalizeSymbol(symbol) {
+        const upper = symbol.toUpperCase().trim();
+        if (!upper)
+            return "";
+        if (upper.endsWith("-USD-PERP"))
+            return upper;
+        if (upper.endsWith("-PERP")) {
+            return upper.replace("-PERP", "-USD-PERP");
+        }
+        return `${upper}-USD-PERP`;
+    }
+    toParadexOrderType(type) {
+        if (type === "market")
+            return "MARKET";
+        return "LIMIT";
+    }
+    async signOrder(args) {
+        const chainId = await this.getStarkChainId();
+        const typed = {
+            domain: {
+                name: "Paradex",
+                chainId,
+                version: "1",
+            },
+            primaryType: "Order",
+            types: {
+                StarkNetDomain: [
+                    { name: "name", type: "felt" },
+                    { name: "chainId", type: "felt" },
+                    { name: "version", type: "felt" },
+                ],
+                Order: [
+                    { name: "timestamp", type: "felt" },
+                    { name: "market", type: "felt" },
+                    { name: "side", type: "felt" },
+                    { name: "orderType", type: "felt" },
+                    { name: "size", type: "felt" },
+                    { name: "price", type: "felt" },
+                ],
+            },
+            message: {
+                timestamp: String(args.signatureTimestamp),
+                market: shortString.encodeShortString(args.market),
+                side: args.side === "BUY" ? "1" : "2",
+                orderType: shortString.encodeShortString(args.type),
+                size: this.toQuantums(args.size, 8),
+                price: this.toQuantums(args.price, 8),
+            },
+        };
+        const messageHash = starkTypedData.getMessageHash(typed, args.account);
+        const signature = ec.starkCurve.sign(messageHash, args.privateKey);
+        return JSON.stringify([signature.r.toString(), signature.s.toString()]);
+    }
+    toOrder(row) {
+        const market = this.normalizeSymbol(pickString(row, ["market", "symbol"]) ?? "");
+        if (!market)
+            return null;
+        const sideRaw = pickString(row, ["side"])?.toLowerCase() ?? "buy";
+        const side = sideRaw === "sell" ? "short" : "long";
+        const typeRaw = pickString(row, ["type", "order_type"])?.toLowerCase() ?? "limit";
+        const type = typeRaw.includes("market") ? "market" : "limit";
+        const size = pickString(row, ["size", "remaining_size", "quantity"]) ?? "0";
+        const filled = pickString(row, ["filled_size", "filled", "executed_quantity"]) ?? "0";
+        const remaining = pickString(row, ["remaining_size", "remaining"]) ??
+            Math.max(0, parseFloat(size) - parseFloat(filled)).toString();
+        const statusRaw = pickString(row, ["status"])?.toLowerCase() ?? "open";
+        const status = statusRaw.includes("cancel")
+            ? "cancelled"
+            : statusRaw.includes("fill")
+                ? parseFloat(remaining) > 0
+                    ? "partial"
+                    : "filled"
+                : statusRaw.includes("expire") || statusRaw.includes("reject")
+                    ? "expired"
+                    : "open";
+        return {
+            id: pickString(row, ["id", "order_id", "client_id"]) ?? `${Date.now()}`,
+            market,
+            side,
+            type,
+            size,
+            price: pickString(row, ["price"]),
+            filled,
+            remaining,
+            status,
+            reduceOnly: pickBoolean(row, ["reduce_only"], false),
+            postOnly: pickBoolean(row, ["post_only"], false),
+            timestamp: toTimestampMs(pickUnknown(row, ["created_at", "updated_at"]), Date.now()),
+            triggerPrice: pickString(row, ["trigger_price"]) ?? undefined,
+        };
+    }
+    toQuantums(value, decimals) {
+        const scaled = decimalToScaled(value, decimals);
+        return scaled.toString();
+    }
+}
+// Register the adapter
+registerAdapter("paradex", () => new ParadexAdapter());
+export default ParadexAdapter;