@raintree-technology/perps 0.1.0

package/dist/adapters/orderly.js

@@ -0,0 +1,936 @@
+/**
+ * Orderly Network Adapter
+ * Implements PerpDEXAdapter interface for Orderly Network
+ *
+ * API Docs: https://orderly.network/docs
+ * Base URL: https://api-evm.orderly.org/v1
+ */
+import { KeyPair } from "near-api-js";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { keccak_256 } from "@noble/hashes/sha3";
+import { bytesToHex } from "@noble/hashes/utils";
+import { registerAdapter, } from "./interface.js";
+import { fetchWithTimeout } from "../lib/fetch.js";
+import { createLogger } from "../lib/logger.js";
+import { MAJOR_MARKETS } from "../lib/constants.js";
+import { isRecord, pickArray, pickObject, pickUnknown, pickString, pickNumber, pickBoolean, toTimestampMs } from "./utils.js";
+const log = createLogger("orderly");
+export class OrderlyAdapter {
+    info = {
+        id: "orderly",
+        name: "Orderly Network",
+        type: "dex",
+        chains: ["arbitrum", "optimism", "polygon", "base"],
+        features: {
+            spot: true,
+            perp: true,
+            margin: true,
+            crossMargin: true,
+            isolatedMargin: false,
+            stopOrders: true,
+            takeProfitOrders: true,
+            postOnly: true,
+            reduceOnly: true,
+            subaccounts: false,
+            modifyOrders: false,
+            batchOrders: true,
+            cancelAllAfter: true,
+            publicTrades: true,
+            fundingHistory: true,
+            orderHistory: true,
+            mmp: false,
+            twapOrders: false,
+        },
+        urls: {
+            app: "https://app.orderly.network",
+            api: "https://api-evm.orderly.org/v1",
+            docs: "https://orderly.network/docs",
+            testnet: "https://testnet-api.orderly.org/v1",
+        },
+        implementation: {
+            marketData: "full",
+            authenticatedReads: "full",
+            orderLifecycle: "full",
+            orderCancellation: "full",
+            subscriptions: "full",
+            advancedTrading: "full",
+        },
+    };
+    baseUrl = "https://api-evm.orderly.org/v1";
+    config = null;
+    connected = false;
+    marketsCache = null;
+    subscriptionTimers = new Set();
+    async connect(config) {
+        this.config = config;
+        const configuredBase = config.credentials?.restUrl;
+        const network = config.credentials?.network;
+        if (configuredBase) {
+            this.baseUrl = configuredBase.replace(/\/$/, "");
+        }
+        else if (network === "testnet" || (network !== "mainnet" && config.testnet)) {
+            this.baseUrl = "https://testnet-api.orderly.org/v1";
+        }
+        else {
+            this.baseUrl = "https://api-evm.orderly.org/v1";
+        }
+        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.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    // --------------------------------------------------------------------------
+    // Private API helpers
+    // --------------------------------------------------------------------------
+    async fetchPublic(endpoint, options) {
+        const url = `${this.baseUrl}${endpoint}`;
+        log.debug(`Fetching ${endpoint}`);
+        return fetchWithTimeout(url, options);
+    }
+    async fetchPrivate(args) {
+        const auth = this.getAuthConfig(!!args.signedPayload);
+        let payload = args.body;
+        const query = { ...(args.query ?? {}) };
+        if (args.signedPayload) {
+            if (!auth.tradingSecret) {
+                throw new Error("Orderly write operations require ORDERLY_TRADING_SECRET");
+            }
+            const withSignature = {
+                ...args.signedPayload,
+            };
+            withSignature.signature = this.signTradingPayload(withSignature, auth.tradingSecret);
+            if (args.method === "DELETE") {
+                for (const [key, value] of Object.entries(withSignature)) {
+                    query[key] = stringifyValue(value);
+                }
+            }
+            else {
+                payload = withSignature;
+            }
+        }
+        const queryString = this.buildQueryString(query);
+        const endpointPath = `${args.endpoint}${queryString}`;
+        const signingPath = `/v1${endpointPath}`;
+        const includeQuery = args.method === "GET" || (args.method === "DELETE" && !payload);
+        const signaturePayload = includeQuery ? "" : payload ? JSON.stringify(payload) : "";
+        const headers = this.buildSignedHeaders({
+            method: args.method,
+            signingPath,
+            signaturePayload,
+            auth,
+            includeTradingKey: !!args.signedPayload,
+        });
+        const url = `${this.baseUrl}${endpointPath}`;
+        const response = await fetchWithTimeout(url, {
+            method: args.method,
+            headers,
+            body: payload ? JSON.stringify(payload) : undefined,
+        });
+        if (isRecord(response) && response.success === false) {
+            const message = (typeof response.message === "string" && response.message) || "Orderly request failed";
+            throw new Error(message);
+        }
+        return response;
+    }
+    async fetchMarkets() {
+        if (this.marketsCache)
+            return this.marketsCache;
+        const response = await this.fetchPublic("/public/info");
+        if (!response.success) {
+            throw new Error("Failed to fetch Orderly markets");
+        }
+        this.marketsCache = response.data.rows.filter((m) => m.symbol.startsWith("PERP_"));
+        return this.marketsCache;
+    }
+    getAuthConfig(requireTrading) {
+        const credentials = this.config?.credentials;
+        const accountId = credentials?.orderlyAccountId ?? credentials?.accountAddress ?? credentials?.subaccountId;
+        const key = credentials?.orderlyKey ?? credentials?.apiKey;
+        const secret = credentials?.orderlySecret ?? credentials?.apiSecret;
+        const tradingSecret = credentials?.orderlyTradingSecret ??
+            credentials?.passphrase ??
+            (credentials?.privateKey ? credentials.privateKey : undefined);
+        const tradingKey = credentials?.orderlyTradingKey ??
+            credentials?.subaccountId ??
+            (tradingSecret ? this.deriveTradingPublicKey(tradingSecret) : undefined);
+        if (!accountId || !key || !secret) {
+            throw new Error("Orderly authenticated endpoints require ORDERLY_ACCOUNT_ID, ORDERLY_KEY, and ORDERLY_SECRET");
+        }
+        if (requireTrading && !tradingSecret) {
+            throw new Error("Orderly trading requires ORDERLY_TRADING_SECRET");
+        }
+        return {
+            accountId,
+            key,
+            secret,
+            tradingSecret,
+            tradingKey,
+        };
+    }
+    buildSignedHeaders(args) {
+        const timestamp = Date.now().toString();
+        const signingMessage = `${timestamp}${args.method.toUpperCase()}${args.signingPath}${args.signaturePayload}`;
+        const orderlyKeyPair = KeyPair.fromString(args.auth.secret);
+        const signature = Buffer.from(orderlyKeyPair.sign(Buffer.from(signingMessage)).signature).toString("base64");
+        const headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "orderly-account-id": args.auth.accountId,
+            "orderly-key": args.auth.key,
+            "orderly-signature": signature,
+            "orderly-timestamp": timestamp,
+        };
+        if (args.includeTradingKey && args.auth.tradingKey) {
+            headers["orderly-trading-key"] = args.auth.tradingKey;
+        }
+        return headers;
+    }
+    signTradingPayload(payload, tradingSecret) {
+        const canonical = Object.keys(payload)
+            .sort()
+            .map((key) => `${key}=${stringifyValue(payload[key])}`)
+            .join("&");
+        const privateKeyHex = stripHexPrefix(tradingSecret);
+        const msgHash = keccak_256(new TextEncoder().encode(canonical));
+        const sig = secp256k1.sign(msgHash, privateKeyHex, { lowS: true });
+        const r = sig.r.toString(16).padStart(64, "0");
+        const s = sig.s.toString(16).padStart(64, "0");
+        const recovery = sig.recovery ?? 0;
+        return `${r}${s}0${recovery}`;
+    }
+    deriveTradingPublicKey(tradingSecret) {
+        const pub = secp256k1.getPublicKey(stripHexPrefix(tradingSecret), false);
+        return bytesToHex(pub).slice(2); // remove 04 prefix
+    }
+    buildQueryString(query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null)
+                continue;
+            params.set(key, String(value));
+        }
+        const encoded = params.toString();
+        return encoded ? `?${encoded}` : "";
+    }
+    canUseReadAuth() {
+        const credentials = this.config?.credentials;
+        return !!(credentials &&
+            (credentials.orderlyAccountId ?? credentials.accountAddress) &&
+            (credentials.orderlyKey ?? credentials.apiKey) &&
+            (credentials.orderlySecret ?? credentials.apiSecret));
+    }
+    // --------------------------------------------------------------------------
+    // Public Market Data
+    // --------------------------------------------------------------------------
+    async getMarkets() {
+        const markets = await this.fetchMarkets();
+        return markets.map((m) => {
+            const [_, baseAsset = m.symbol, quoteAsset = "USDC"] = m.symbol.split("_");
+            const maxLeverage = Math.floor(1 / m.base_imr) || 20;
+            return {
+                symbol: this.toStandardSymbol(m.symbol),
+                baseAsset,
+                quoteAsset,
+                type: "perp",
+                maxLeverage,
+                minSize: m.base_tick.toString(),
+                tickSize: m.quote_tick.toString(),
+                fundingInterval: m.funding_period,
+                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 orderlySymbol = this.toOrderlySymbol(market);
+        const markPriceData = await this.fetchPublic(`/public/futures/${orderlySymbol}`);
+        if (!markPriceData.success) {
+            throw new Error(`Market ${market} not found`);
+        }
+        const mp = markPriceData.data;
+        const change24h = mp["24h_close"] && mp["24h_open"]
+            ? (((mp["24h_close"] - mp["24h_open"]) / mp["24h_open"]) * 100).toFixed(2)
+            : "0";
+        // Fetch real bid/ask from orderbook
+        let bid = mp.mark_price.toString();
+        let ask = mp.mark_price.toString();
+        try {
+            const book = await this.fetchPublic(`/public/orderbook/${orderlySymbol}?max_level=1`);
+            const data = pickObject(book, ["data", "result", "results.0"]) ?? {};
+            const bids = this.toBookLevels(pickUnknown(data, ["bids"]));
+            const asks = this.toBookLevels(pickUnknown(data, ["asks"]));
+            if (bids.length > 0)
+                bid = bids[0].price;
+            if (asks.length > 0)
+                ask = asks[0].price;
+        }
+        catch {
+            // Fall back to mark price if orderbook unavailable
+        }
+        return {
+            market: this.toStandardSymbol(orderlySymbol),
+            lastPrice: mp["24h_close"]?.toString() || mp.mark_price.toString(),
+            markPrice: mp.mark_price.toString(),
+            indexPrice: mp.index_price.toString(),
+            bid,
+            ask,
+            volume24h: mp["24h_amount"]?.toString() || "0",
+            change24h,
+            high24h: mp["24h_high"]?.toString() || "0",
+            low24h: mp["24h_low"]?.toString() || "0",
+            openInterest: mp.open_interest.toString(),
+            fundingRate: mp.est_funding_rate.toString(),
+            timestamp: Date.now(),
+        };
+    }
+    async getTickers() {
+        const markets = await this.fetchMarkets();
+        // Use batch public/futures endpoint to avoid N+1 requests
+        const tickers = [];
+        try {
+            const response = await this.fetchPublic("/public/futures");
+            if (response.success && response.data?.rows) {
+                const markPriceMap = new Map();
+                for (const mp of response.data.rows) {
+                    markPriceMap.set(mp.symbol, mp);
+                }
+                for (const m of markets) {
+                    const mp = markPriceMap.get(m.symbol);
+                    if (!mp)
+                        continue;
+                    const change24h = mp["24h_close"] && mp["24h_open"]
+                        ? (((mp["24h_close"] - mp["24h_open"]) / mp["24h_open"]) * 100).toFixed(2)
+                        : "0";
+                    tickers.push({
+                        market: this.toStandardSymbol(m.symbol),
+                        lastPrice: mp["24h_close"]?.toString() || mp.mark_price.toString(),
+                        markPrice: mp.mark_price.toString(),
+                        indexPrice: mp.index_price.toString(),
+                        bid: mp.mark_price.toString(),
+                        ask: mp.mark_price.toString(),
+                        volume24h: mp["24h_amount"]?.toString() || "0",
+                        change24h,
+                        high24h: mp["24h_high"]?.toString() || "0",
+                        low24h: mp["24h_low"]?.toString() || "0",
+                        openInterest: mp.open_interest.toString(),
+                        fundingRate: mp.est_funding_rate.toString(),
+                        timestamp: Date.now(),
+                    });
+                }
+                return tickers;
+            }
+        }
+        catch {
+            // Fall back to individual fetches
+        }
+        // Fallback: sequential per-market
+        for (const m of markets.slice(0, 80)) {
+            try {
+                tickers.push(await this.getTicker(m.symbol));
+            }
+            catch {
+                // Best effort across all symbols.
+            }
+        }
+        return tickers;
+    }
+    async getOrderBook(market, depth = 20) {
+        const orderlySymbol = this.toOrderlySymbol(market);
+        // Orderly has a public orderbook endpoint
+        const response = this.canUseReadAuth()
+            ? await this.fetchPrivate({
+                method: "GET",
+                endpoint: `/orderbook/${orderlySymbol}`,
+                query: { max_level: depth },
+            })
+            : await this.fetchPublic(`/public/orderbook/${orderlySymbol}?max_level=${depth}`);
+        const data = pickObject(response, ["data", "result", "results.0"]) ?? {};
+        const bids = this.toBookLevels(pickUnknown(data, ["bids"]));
+        const asks = this.toBookLevels(pickUnknown(data, ["asks"]));
+        return {
+            market: this.toStandardSymbol(orderlySymbol),
+            bids: bids.slice(0, depth),
+            asks: asks.slice(0, depth),
+            timestamp: toTimestampMs(pickUnknown(data, ["timestamp", "updated_time"]), Date.now()),
+        };
+    }
+    async getFundingRate(market) {
+        const orderlySymbol = this.toOrderlySymbol(market);
+        const markPriceData = await this.fetchPublic(`/public/futures/${orderlySymbol}`);
+        if (!markPriceData.success) {
+            throw new Error(`Funding rate not available for ${market}`);
+        }
+        const mp = markPriceData.data;
+        return {
+            market: this.toStandardSymbol(orderlySymbol),
+            rate: mp.est_funding_rate.toString(),
+            nextFundingTime: mp.next_funding_time,
+            timestamp: Date.now(),
+        };
+    }
+    async getFundingRates() {
+        // Use batch futures endpoint to get all funding rates at once
+        try {
+            const response = await this.fetchPublic("/public/futures");
+            if (response.success && response.data?.rows) {
+                return response.data.rows.map((mp) => ({
+                    market: this.toStandardSymbol(mp.symbol),
+                    rate: mp.est_funding_rate.toString(),
+                    nextFundingTime: mp.next_funding_time,
+                    timestamp: Date.now(),
+                }));
+            }
+        }
+        catch {
+            // Fall back to individual fetches
+        }
+        const rates = [];
+        for (const market of MAJOR_MARKETS) {
+            try {
+                rates.push(await this.getFundingRate(market));
+            }
+            catch {
+                // Best effort across majors.
+            }
+        }
+        return rates;
+    }
+    // --------------------------------------------------------------------------
+    // Account Data (requires auth)
+    // --------------------------------------------------------------------------
+    async getPositions() {
+        const response = await this.fetchPrivate({
+            method: "GET",
+            endpoint: "/positions",
+        });
+        const rows = pickArray(response, ["data.rows", "rows", "data", "results"]);
+        return rows
+            .map((row) => {
+            const symbol = this.toStandardSymbol(pickString(row, ["symbol", "market", "instrument_name"]) ?? "");
+            if (!symbol)
+                return null;
+            const quantity = pickNumber(row, ["position_qty", "quantity", "size", "holding"], 0);
+            if (quantity === 0)
+                return null;
+            const side = quantity < 0 ? "short" : "long";
+            const absSize = Math.abs(quantity);
+            return {
+                market: symbol,
+                side,
+                size: absSize.toString(),
+                entryPrice: pickString(row, ["average_open_price", "entry_price", "avg_price"]) ?? "0",
+                markPrice: pickString(row, ["mark_price", "close_price", "last_price"]) ?? "0",
+                liquidationPrice: pickString(row, ["est_liq_price", "liquidation_price"]) ?? null,
+                unrealizedPnl: pickString(row, ["unrealized_pnl", "pnl_24_h"]) ?? "0",
+                realizedPnl: pickString(row, ["realized_pnl"]) ?? "0",
+                leverage: pickNumber(row, ["leverage"], 1),
+                marginType: "cross",
+                margin: pickString(row, ["position_margin", "initial_margin"]) ?? "0",
+                timestamp: toTimestampMs(pickUnknown(row, ["updated_time", "created_time", "timestamp"]), 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 response = await this.fetchPrivate({
+            method: "GET",
+            endpoint: "/orders",
+            query: {
+                symbol: market ? this.toOrderlySymbol(market) : undefined,
+                size: 500,
+            },
+        });
+        const rows = pickArray(response, ["data.rows", "rows", "data", "results"]);
+        return rows
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+    }
+    async getOrder(orderId) {
+        const response = await this.fetchPrivate({
+            method: "GET",
+            endpoint: `/order/${encodeURIComponent(orderId)}`,
+        });
+        const row = pickObject(response, ["data", "result", "results.0"]) ??
+            pickArray(response, ["rows", "data.rows"])[0] ??
+            null;
+        if (row) {
+            const mapped = this.toOrder(row);
+            if (mapped)
+                return mapped;
+        }
+        const orders = await this.getOrders();
+        return orders.find((o) => o.id === orderId) ?? null;
+    }
+    async getBalances() {
+        const response = await this.fetchPrivate({
+            method: "GET",
+            endpoint: "/client/holding",
+            query: { all: "true" },
+        });
+        // Fetch positions to compute unrealized PnL
+        let totalUnrealizedPnl = 0;
+        let totalMarginUsed = 0;
+        try {
+            const positions = await this.getPositions();
+            for (const p of positions) {
+                totalUnrealizedPnl += parseFloat(p.unrealizedPnl || "0");
+                totalMarginUsed += parseFloat(p.margin || "0");
+            }
+        }
+        catch {
+            // Best effort - continue without position data
+        }
+        const rows = pickArray(response, ["data.holding", "data.rows", "rows", "results"]);
+        if (rows.length > 0) {
+            return rows.map((row) => {
+                const holding = pickNumber(row, ["holding", "balance"], 0);
+                const frozen = pickNumber(row, ["frozen", "locked"], 0);
+                const total = holding + frozen;
+                return {
+                    asset: pickString(row, ["token", "asset", "currency"]) ?? "USDC",
+                    total: total.toString(),
+                    available: holding.toString(),
+                    locked: frozen.toString(),
+                    unrealizedPnl: totalUnrealizedPnl.toString(),
+                    marginUsed: totalMarginUsed > 0 ? totalMarginUsed.toString() : frozen.toString(),
+                };
+            });
+        }
+        const info = await this.fetchPrivate({ method: "GET", endpoint: "/client/info" });
+        const data = pickObject(info, ["data", "result", "results.0"]) ?? {};
+        const total = pickString(data, ["equity", "balance"]) ?? "0";
+        const available = pickString(data, ["free_collateral", "available_balance"]) ?? total;
+        return [
+            {
+                asset: "USDC",
+                total,
+                available,
+                locked: totalMarginUsed > 0 ? totalMarginUsed.toString() : "0",
+                unrealizedPnl: totalUnrealizedPnl.toString(),
+                marginUsed: totalMarginUsed > 0 ? totalMarginUsed.toString() : "0",
+            },
+        ];
+    }
+    async getTrades(market, limit = 100) {
+        const response = await this.fetchPrivate({
+            method: "GET",
+            endpoint: "/trades",
+            query: {
+                symbol: market ? this.toOrderlySymbol(market) : undefined,
+                size: Math.max(1, Math.min(limit, 500)),
+            },
+        });
+        const rows = pickArray(response, ["data.rows", "rows", "data", "results"]);
+        return rows
+            .map((row) => {
+            const symbol = this.toStandardSymbol(pickString(row, ["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", "trade_id", "execution_id"]) ?? `${symbol}-${Date.now()}`,
+                market: symbol,
+                side,
+                price: pickString(row, ["executed_price", "price"]) ?? "0",
+                size: pickString(row, ["executed_quantity", "size", "quantity"]) ?? "0",
+                fee: pickString(row, ["fee", "total_fee"]) ?? "0",
+                feeAsset: pickString(row, ["fee_asset", "fee_currency"]) ?? "USDC",
+                timestamp: toTimestampMs(pickUnknown(row, ["executed_timestamp", "created_time", "timestamp"]), Date.now()),
+                ...(orderId ? { orderId } : {}),
+            };
+        })
+            .filter((row) => row !== null);
+    }
+    // --------------------------------------------------------------------------
+    // Trading
+    // --------------------------------------------------------------------------
+    async placeOrder(params) {
+        const symbol = this.toOrderlySymbol(params.market);
+        const payload = {
+            symbol,
+            side: params.side === "long" ? "BUY" : "SELL",
+            order_type: this.toOrderlyOrderType(params.type),
+            order_quantity: params.size,
+            client_order_id: params.clientOrderId,
+        };
+        if (params.type !== "market") {
+            if (!params.price) {
+                throw new Error("Order price is required for non-market orders");
+            }
+            payload.order_price = params.price;
+        }
+        const response = await this.fetchPrivate({
+            method: "POST",
+            endpoint: "/order",
+            body: payload,
+            signedPayload: payload,
+        });
+        const data = pickObject(response, ["data", "result", "results.0"]) ?? payload;
+        const mapped = this.toOrder(data);
+        if (mapped) {
+            return mapped;
+        }
+        return {
+            id: pickString(data, ["order_id", "id", "client_order_id"]) ?? `${Date.now()}`,
+            market: this.toStandardSymbol(symbol),
+            side: params.side,
+            type: params.type,
+            size: params.size,
+            price: params.price ?? null,
+            filled: "0",
+            remaining: params.size,
+            status: "open",
+            reduceOnly: params.reduceOnly ?? false,
+            postOnly: params.postOnly ?? false,
+            timestamp: Date.now(),
+            triggerPrice: params.triggerPrice,
+        };
+    }
+    async cancelOrder(params) {
+        const payload = {};
+        if (params.orderId) {
+            payload.order_id = params.orderId;
+        }
+        if (params.clientOrderId) {
+            payload.client_order_id = params.clientOrderId;
+        }
+        if (Object.keys(payload).length === 0) {
+            throw new Error("cancelOrder requires orderId or clientOrderId");
+        }
+        await this.fetchPrivate({
+            method: "DELETE",
+            endpoint: "/order",
+            query: payload,
+            signedPayload: payload,
+        });
+        return true;
+    }
+    async cancelAllOrders(market) {
+        const payload = {};
+        if (market) {
+            payload.symbol = this.toOrderlySymbol(market);
+        }
+        const response = await this.fetchPrivate({
+            method: "DELETE",
+            endpoint: "/orders",
+            query: payload,
+            signedPayload: payload,
+        });
+        const count = pickNumber(response, ["data.count", "count", "cancelled"], NaN);
+        if (Number.isFinite(count) && count >= 0) {
+            return Math.floor(count);
+        }
+        return market ? 1 : 0;
+    }
+    async setLeverage(_market, leverage) {
+        const payload = { leverage };
+        await this.fetchPrivate({
+            method: "POST",
+            endpoint: "/client/leverage",
+            body: payload,
+            signedPayload: payload,
+        });
+    }
+    async setMarginType(_market, type) {
+        if (type !== "cross") {
+            throw new Error("Orderly currently supports cross margin only");
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Advanced Trading
+    // --------------------------------------------------------------------------
+    async modifyOrder(_params) {
+        throw new Error("Orderly does not support order modification. Cancel and replace instead.");
+    }
+    async batchPlaceOrders(paramsList) {
+        // Orderly has batch create order endpoint
+        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) {
+        // Orderly cancel_all_after endpoint
+        const payload = {
+            cancel_after: Math.max(0, Math.floor(timeoutMs / 1000)),
+        };
+        await this.fetchPrivate({
+            method: "POST",
+            endpoint: "/cancel_all_after",
+            body: payload,
+            signedPayload: payload,
+        });
+    }
+    async getOrderHistory(market, limit = 100) {
+        const response = await this.fetchPrivate({
+            method: "GET",
+            endpoint: "/orders",
+            query: {
+                symbol: market ? this.toOrderlySymbol(market) : undefined,
+                size: Math.max(1, Math.min(limit, 500)),
+                status: "COMPLETED",
+            },
+        });
+        const rows = pickArray(response, ["data.rows", "rows", "data", "results"]);
+        return rows
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+    }
+    async getFundingHistory(market, limit = 100) {
+        const response = await this.fetchPrivate({
+            method: "GET",
+            endpoint: "/funding_fee/history",
+            query: {
+                symbol: market ? this.toOrderlySymbol(market) : undefined,
+                size: Math.max(1, Math.min(limit, 500)),
+            },
+        });
+        const rows = pickArray(response, ["data.rows", "rows", "data", "results"]);
+        return rows.map((row) => ({
+            market: this.toStandardSymbol(pickString(row, ["symbol"]) ?? ""),
+            amount: pickString(row, ["funding_fee", "fee", "payment"]) ?? "0",
+            rate: pickString(row, ["funding_rate", "rate"]) ?? "0",
+            timestamp: toTimestampMs(pickUnknown(row, ["created_time", "timestamp"]), Date.now()),
+        }));
+    }
+    async getPublicTrades(market, limit = 100) {
+        const orderlySymbol = this.toOrderlySymbol(market);
+        const response = await this.fetchPublic(`/public/market_trades?symbol=${orderlySymbol}&limit=${Math.min(limit, 100)}`);
+        const rows = pickArray(response, ["data.rows", "rows", "data", "results"]);
+        return rows.map((row) => ({
+            id: pickString(row, ["id", "trade_id"]) ?? `${Date.now()}`,
+            market: this.toStandardSymbol(orderlySymbol),
+            side: (pickString(row, ["side"])?.toLowerCase() === "sell" ? "short" : "long"),
+            price: pickString(row, ["executed_price", "price"]) ?? "0",
+            size: pickString(row, ["executed_quantity", "size", "quantity"]) ?? "0",
+            timestamp: toTimestampMs(pickUnknown(row, ["executed_timestamp", "timestamp"]), Date.now()),
+        }));
+    }
+    // --------------------------------------------------------------------------
+    // Market Maker Protection
+    // --------------------------------------------------------------------------
+    async setMMP(_config) {
+        throw new Error("Orderly does not support Market Maker Protection (MMP)");
+    }
+    async getMMP(_market) {
+        throw new Error("Orderly does not support Market Maker Protection (MMP)");
+    }
+    async resetMMP(_market) {
+        throw new Error("Orderly does not support Market Maker Protection (MMP)");
+    }
+    // --------------------------------------------------------------------------
+    // TWAP Orders
+    // --------------------------------------------------------------------------
+    async placeTWAP(_params) {
+        throw new Error("Orderly does not support TWAP orders");
+    }
+    async cancelTWAP(_twapId) {
+        throw new Error("Orderly does not support TWAP orders");
+    }
+    async getTWAPStatus(_twapId) {
+        throw new Error("Orderly does not support TWAP orders");
+    }
+    // --------------------------------------------------------------------------
+    // Margin Management
+    // --------------------------------------------------------------------------
+    async updateIsolatedMargin(_market, _amount) {
+        throw new Error("Orderly 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 normalized = this.normalizeSymbol(market);
+        const timer = setInterval(async () => {
+            try {
+                callback(await this.getOrderBook(normalized));
+            }
+            catch {
+                // Ignore transient polling errors.
+            }
+        }, 1500);
+        this.subscriptionTimers.add(timer);
+        return () => {
+            clearInterval(timer);
+            this.subscriptionTimers.delete(timer);
+        };
+    }
+    subscribeTicker(market, callback) {
+        const normalized = this.normalizeSymbol(market);
+        const timer = setInterval(async () => {
+            try {
+                callback(await this.getTicker(normalized));
+            }
+            catch {
+                // Ignore transient polling errors.
+            }
+        }, 1200);
+        this.subscriptionTimers.add(timer);
+        return () => {
+            clearInterval(timer);
+            this.subscriptionTimers.delete(timer);
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Private Helpers
+    // --------------------------------------------------------------------------
+    toOrderlyOrderType(type) {
+        if (type === "market")
+            return "MARKET";
+        return "LIMIT";
+    }
+    toOrderlySymbol(symbol) {
+        const upper = symbol.toUpperCase().trim();
+        if (upper.startsWith("PERP_"))
+            return upper;
+        const base = upper
+            .replace("-USD-PERP", "")
+            .replace("-PERP", "")
+            .replace("/USDC", "")
+            .replace("/USD", "");
+        return `PERP_${base}_USDC`;
+    }
+    toStandardSymbol(orderlySymbol) {
+        const parts = orderlySymbol.split("_");
+        if (parts.length >= 2 && parts[0] === "PERP") {
+            return `${parts[1]}-PERP`;
+        }
+        if (!orderlySymbol)
+            return "";
+        const normalized = orderlySymbol.toUpperCase();
+        if (normalized.endsWith("-PERP"))
+            return normalized;
+        return `${normalized}-PERP`;
+    }
+    normalizeSymbol(symbol) {
+        const upper = symbol.toUpperCase().trim();
+        if (!upper)
+            return "";
+        if (upper.startsWith("PERP_")) {
+            return this.toStandardSymbol(upper);
+        }
+        if (upper.endsWith("-PERP"))
+            return upper;
+        return `${upper}-PERP`;
+    }
+    toOrder(row) {
+        const market = this.toStandardSymbol(pickString(row, ["symbol", "market", "instrument_name"]) ?? "");
+        if (!market)
+            return null;
+        const sideRaw = pickString(row, ["side"])?.toLowerCase() ?? "buy";
+        const side = sideRaw === "sell" ? "short" : "long";
+        const size = pickString(row, ["quantity", "order_quantity", "size"]) ?? "0";
+        const filled = pickString(row, ["executed", "executed_quantity", "filled"]) ?? "0";
+        const remaining = pickString(row, ["remaining", "leaves_qty"]) ??
+            Math.max(0, parseFloat(size) - parseFloat(filled)).toString();
+        const statusRaw = pickString(row, ["status"])?.toLowerCase() ?? "new";
+        const status = statusRaw.includes("cancel")
+            ? "cancelled"
+            : statusRaw.includes("filled")
+                ? parseFloat(remaining) > 0
+                    ? "partial"
+                    : "filled"
+                : statusRaw.includes("reject") || statusRaw.includes("expire")
+                    ? "expired"
+                    : "open";
+        const typeRaw = pickString(row, ["type", "order_type"])?.toLowerCase() ?? "limit";
+        const type = typeRaw.includes("market") ? "market" : "limit";
+        return {
+            id: pickString(row, ["order_id", "id", "client_order_id"]) ?? `${Date.now()}`,
+            market,
+            side,
+            type,
+            size,
+            price: pickString(row, ["price", "order_price"]),
+            filled,
+            remaining,
+            status,
+            reduceOnly: pickBoolean(row, ["reduce_only", "reduce_only_order"], false),
+            postOnly: pickBoolean(row, ["post_only"], false),
+            timestamp: toTimestampMs(pickUnknown(row, ["created_time", "updated_time", "timestamp"]), Date.now()),
+            triggerPrice: pickString(row, ["trigger_price"]) ?? undefined,
+        };
+    }
+    toBookLevels(value) {
+        if (!Array.isArray(value))
+            return [];
+        const levels = [];
+        for (const row of value) {
+            if (!Array.isArray(row) || row.length < 2)
+                continue;
+            const [price, size] = row;
+            const priceStr = stringifyValue(price);
+            const sizeStr = stringifyValue(size);
+            levels.push({ price: priceStr, size: sizeStr });
+        }
+        return levels;
+    }
+}
+function stripHexPrefix(value) {
+    return value.startsWith("0x") ? value.slice(2) : value;
+}
+function stringifyValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
+        return String(value);
+    }
+    return "";
+}
+// Register the adapter
+registerAdapter("orderly", () => new OrderlyAdapter());
+export default OrderlyAdapter;