@raintree-technology/perps 0.1.0

package/dist/adapters/aevo.js

@@ -0,0 +1,899 @@
+/**
+ * Aevo Adapter
+ * Implements PerpDEXAdapter interface for Aevo DEX
+ *
+ * API Docs: https://docs.aevo.xyz/
+ * Base URL: https://api.aevo.xyz
+ */
+import { privateKeyToAccount } from "viem/accounts";
+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 { isRecord, pickArray, pickObject, pickUnknown, pickString, pickNumber, pickBoolean, toTimestampMs, decimalToScaled, decimalPlaces } from "./utils.js";
+const log = createLogger("aevo");
+export class AevoAdapter {
+    info = {
+        id: "aevo",
+        name: "Aevo",
+        type: "dex",
+        chains: ["ethereum"],
+        features: {
+            spot: false,
+            perp: true,
+            margin: true,
+            crossMargin: true,
+            isolatedMargin: false,
+            stopOrders: true,
+            takeProfitOrders: true,
+            postOnly: true,
+            reduceOnly: true,
+            subaccounts: false,
+            modifyOrders: true,
+            batchOrders: true,
+            cancelAllAfter: false,
+            publicTrades: true,
+            fundingHistory: true,
+            orderHistory: true,
+            mmp: true,
+            twapOrders: false,
+        },
+        urls: {
+            app: "https://app.aevo.xyz",
+            api: "https://api.aevo.xyz",
+            docs: "https://docs.aevo.xyz",
+            testnet: "https://api-testnet.aevo.xyz",
+        },
+        implementation: {
+            marketData: "full",
+            authenticatedReads: "full",
+            orderLifecycle: "full",
+            orderCancellation: "full",
+            subscriptions: "full",
+            advancedTrading: "full",
+        },
+    };
+    baseUrl = "https://api.aevo.xyz";
+    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://api-testnet.aevo.xyz";
+        }
+        else {
+            this.baseUrl = "https://api.aevo.xyz";
+        }
+        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 fetch(endpoint, options) {
+        const url = `${this.baseUrl}${endpoint}`;
+        log.debug(`Fetching ${endpoint}`);
+        return fetchWithTimeout(url, options);
+    }
+    async fetchAuthed(endpoint, options) {
+        const headers = {
+            ...this.getAuthHeaders(),
+            ...(options?.headers ?? {}),
+        };
+        return this.fetch(endpoint, {
+            ...options,
+            headers,
+        });
+    }
+    getAuthHeaders() {
+        const apiKey = this.config?.credentials?.apiKey;
+        const apiSecret = this.config?.credentials?.apiSecret;
+        if (!apiKey || !apiSecret) {
+            throw new Error("Aevo authenticated endpoints require API key + secret");
+        }
+        return {
+            AEVO_KEY: apiKey,
+            AEVO_SECRET: apiSecret,
+            "AEVO-KEY": apiKey,
+            "AEVO-SECRET": apiSecret,
+        };
+    }
+    async fetchMarkets() {
+        if (this.marketsCache)
+            return this.marketsCache;
+        const markets = await this.fetch("/markets");
+        this.marketsCache = markets.filter((m) => m.instrument_type === "PERPETUAL");
+        return this.marketsCache;
+    }
+    // --------------------------------------------------------------------------
+    // Public Market Data
+    // --------------------------------------------------------------------------
+    async getMarkets() {
+        const markets = await this.fetchMarkets();
+        return markets.map((m) => ({
+            symbol: m.instrument_name,
+            baseAsset: m.underlying_asset,
+            quoteAsset: m.quote_asset,
+            type: "perp",
+            maxLeverage: parseInt(m.max_leverage, 10) || 20,
+            minSize: m.amount_step,
+            tickSize: m.price_step,
+            fundingInterval: FUNDING_INTERVAL_HOURS,
+            isActive: m.is_active,
+        }));
+    }
+    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 markets = await this.fetchMarkets();
+        const m = markets.find((row) => row.instrument_name === symbol);
+        if (!m)
+            throw new Error(`Market ${market} not found`);
+        let fundingRate = "0";
+        try {
+            const funding = await this.fetch(`/funding?instrument_name=${symbol}`);
+            fundingRate = funding.funding_rate;
+        }
+        catch {
+            // Some symbols can temporarily omit funding.
+        }
+        // Fetch statistics for volume, OI, 24h change
+        let volume24h = "0";
+        let change24h = "0";
+        let openInterest = "0";
+        let high24h = "0";
+        let low24h = "0";
+        try {
+            const stats = await this.fetch(`/statistics?instrument_name=${encodeURIComponent(symbol)}`);
+            volume24h = stats.daily_volume ?? "0";
+            openInterest = stats.open_interest ?? "0";
+            if (stats.mark_daily_change) {
+                change24h = (parseFloat(stats.mark_daily_change) * 100).toFixed(2);
+            }
+        }
+        catch {
+            // Statistics endpoint may not be available for all symbols.
+        }
+        // Use orderbook top-of-book for bid/ask
+        let bid = m.mark_price;
+        let ask = m.mark_price;
+        try {
+            const book = await this.fetch(`/orderbook?instrument_name=${symbol}`);
+            if (book.bids?.length > 0)
+                bid = book.bids[0][0];
+            if (book.asks?.length > 0)
+                ask = book.asks[0][0];
+        }
+        catch {
+            // Fall back to mark price if orderbook unavailable.
+        }
+        return {
+            market: symbol,
+            lastPrice: m.mark_price,
+            markPrice: m.mark_price,
+            indexPrice: m.index_price,
+            bid,
+            ask,
+            volume24h,
+            change24h,
+            high24h,
+            low24h,
+            openInterest,
+            fundingRate,
+            timestamp: Date.now(),
+        };
+    }
+    async getTickers() {
+        const markets = await this.fetchMarkets();
+        // Batch fetch statistics for all markets
+        const statsMap = new Map();
+        try {
+            const allStats = await this.fetch("/statistics");
+            if (Array.isArray(allStats)) {
+                for (const stat of allStats) {
+                    if (stat.instrument_name) {
+                        statsMap.set(stat.instrument_name, stat);
+                    }
+                }
+            }
+        }
+        catch {
+            // Statistics endpoint may return individual stats or fail.
+        }
+        return markets.map((m) => {
+            const stats = statsMap.get(m.instrument_name);
+            const change = stats?.mark_daily_change
+                ? (parseFloat(stats.mark_daily_change) * 100).toFixed(2)
+                : "0";
+            return {
+                market: m.instrument_name,
+                lastPrice: m.mark_price,
+                markPrice: m.mark_price,
+                indexPrice: m.index_price,
+                bid: m.mark_price,
+                ask: m.mark_price,
+                volume24h: stats?.daily_volume ?? "0",
+                change24h: change,
+                high24h: "0",
+                low24h: "0",
+                openInterest: stats?.open_interest ?? "0",
+                fundingRate: stats?.funding_daily_avg ?? "0",
+                timestamp: Date.now(),
+            };
+        });
+    }
+    async getOrderBook(market, depth = 20) {
+        const symbol = this.normalizeSymbol(market);
+        const book = await this.fetch(`/orderbook?instrument_name=${symbol}`);
+        return {
+            market: symbol,
+            bids: book.bids.slice(0, depth).map(([price, size]) => ({ price, size })),
+            asks: book.asks.slice(0, depth).map(([price, size]) => ({ price, size })),
+            timestamp: toTimestampMs(book.last_updated, Date.now()),
+        };
+    }
+    async getFundingRate(market) {
+        const symbol = this.normalizeSymbol(market);
+        const funding = await this.fetch(`/funding?instrument_name=${symbol}`);
+        return {
+            market: symbol,
+            rate: funding.funding_rate,
+            nextFundingTime: toTimestampMs(funding.next_funding_time, Date.now() + 8 * 3600000),
+            timestamp: Date.now(),
+        };
+    }
+    async getFundingRates() {
+        const markets = await this.fetchMarkets();
+        const rates = [];
+        for (const m of markets) {
+            try {
+                const rate = await this.getFundingRate(m.instrument_name);
+                rates.push(rate);
+            }
+            catch {
+                // Best effort across all markets.
+            }
+        }
+        return rates;
+    }
+    // --------------------------------------------------------------------------
+    // Account Data (requires auth)
+    // --------------------------------------------------------------------------
+    async getPositions() {
+        this.ensureAuth();
+        const response = await this.fetchAuthed("/positions");
+        const rows = pickArray(response, ["positions", "data.positions", "data.rows", "results"]);
+        return rows
+            .map((row) => {
+            const market = this.normalizeSymbol(pickString(row, ["instrument_name", "market", "symbol"]) ?? "");
+            if (!market)
+                return null;
+            const signedSize = pickNumber(row, ["size", "amount", "position_size", "quantity"], 0);
+            const sideValue = pickString(row, ["side"])?.toLowerCase();
+            const side = sideValue === "sell" || sideValue === "short" || signedSize < 0 ? "short" : "long";
+            const absSize = Math.abs(signedSize);
+            if (absSize === 0)
+                return null;
+            const entryPrice = pickString(row, ["entry_price", "avg_entry_price", "average_entry_price"]) ?? "0";
+            const markPrice = pickString(row, ["mark_price", "last_price", "index_price"]) ?? entryPrice;
+            return {
+                market,
+                side,
+                size: absSize.toString(),
+                entryPrice,
+                markPrice,
+                liquidationPrice: pickString(row, ["liquidation_price", "liq_price", "estimated_liquidation_price"]) ??
+                    null,
+                unrealizedPnl: pickString(row, ["unrealized_pnl", "upnl", "pnl"]) ?? "0",
+                realizedPnl: pickString(row, ["realized_pnl", "rpnl"]) ?? "0",
+                leverage: pickNumber(row, ["leverage"], 1),
+                marginType: "cross",
+                margin: pickString(row, ["margin", "margin_used", "initial_margin"]) ?? "0",
+                timestamp: toTimestampMs(pickUnknown(row, ["updated_at", "timestamp", "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) {
+        this.ensureAuth();
+        const query = market ? `?instrument_name=${encodeURIComponent(this.normalizeSymbol(market))}` : "";
+        const response = await this.fetchAuthed(`/orders${query}`);
+        const rows = pickArray(response, ["orders", "data.orders", "data.rows", "results"]);
+        return rows
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+    }
+    async getOrder(orderId) {
+        this.ensureAuth();
+        try {
+            const response = await this.fetchAuthed(`/orders/${encodeURIComponent(orderId)}`);
+            const rows = pickArray(response, ["order", "data", "results"]);
+            if (rows.length > 0) {
+                return this.toOrder(rows[0]);
+            }
+            if (isRecord(response)) {
+                return this.toOrder(response);
+            }
+        }
+        catch {
+            // Fall through to broader lookup below.
+        }
+        const orders = await this.getOrders();
+        return orders.find((o) => o.id === orderId) ?? null;
+    }
+    async getBalances() {
+        this.ensureAuth();
+        const response = await this.fetchAuthed("/account");
+        const balanceRows = pickArray(response, ["balances", "data.balances", "results"]);
+        if (balanceRows.length > 0) {
+            return balanceRows.map((row) => {
+                const asset = pickString(row, ["asset", "symbol", "token"]) ?? "USD";
+                const total = pickString(row, ["total", "balance", "equity"]) ?? "0";
+                const available = pickString(row, ["available", "available_balance", "free"]) ?? total;
+                const locked = pickString(row, ["locked", "margin_used", "in_orders"]) ?? "0";
+                const unrealizedPnl = pickString(row, ["unrealized_pnl", "upnl"]) ?? "0";
+                const marginUsed = pickString(row, ["margin_used", "initial_margin", "maintenance_margin"]) ?? locked;
+                return {
+                    asset,
+                    total,
+                    available,
+                    locked,
+                    unrealizedPnl,
+                    marginUsed,
+                };
+            });
+        }
+        const accountRow = isRecord(response)
+            ? response
+            : pickObject(response, ["account", "data.account", "data", "results.0"]);
+        const total = pickString(accountRow, ["equity", "balance", "total_collateral", "account_value"]) ?? "0";
+        const available = pickString(accountRow, ["available_balance", "available", "free_collateral"]) ?? total;
+        const marginUsed = pickString(accountRow, ["margin_used", "used_margin", "initial_margin"]) ??
+            Math.max(0, parseFloat(total) - parseFloat(available)).toString();
+        return [
+            {
+                asset: "USD",
+                total,
+                available,
+                locked: marginUsed,
+                unrealizedPnl: pickString(accountRow, ["unrealized_pnl", "upnl"]) ?? "0",
+                marginUsed,
+            },
+        ];
+    }
+    async getTrades(market, limit = 100) {
+        this.ensureAuth();
+        const query = new URLSearchParams();
+        if (market)
+            query.set("instrument_name", this.normalizeSymbol(market));
+        if (limit > 0)
+            query.set("limit", String(limit));
+        const suffix = query.size > 0 ? `?${query.toString()}` : "";
+        const response = await this.fetchAuthed(`/trade-history${suffix}`);
+        const rows = pickArray(response, ["trades", "data.trades", "data.rows", "results"]);
+        return rows
+            .map((row) => {
+            const marketSymbol = this.normalizeSymbol(pickString(row, ["instrument_name", "market", "symbol"]) ?? "");
+            if (!marketSymbol)
+                return null;
+            const sideRaw = pickString(row, ["side"])?.toLowerCase() ?? "buy";
+            const side = sideRaw === "sell" || sideRaw === "short" ? "short" : "long";
+            const orderId = pickString(row, ["order_id", "client_order_id"]);
+            return {
+                id: pickString(row, ["trade_id", "id", "fill_id", "execution_id"]) ??
+                    `${marketSymbol}-${Date.now()}`,
+                market: marketSymbol,
+                side,
+                price: pickString(row, ["price", "execution_price", "avg_price"]) ?? "0",
+                size: pickString(row, ["size", "amount", "quantity", "filled_amount"]) ?? "0",
+                fee: pickString(row, ["fee", "fee_paid"]) ?? "0",
+                feeAsset: pickString(row, ["fee_asset", "fee_currency"]) ?? "USD",
+                timestamp: toTimestampMs(pickUnknown(row, ["created_at", "timestamp", "trade_time"]), Date.now()),
+                ...(orderId ? { orderId } : {}),
+            };
+        })
+            .filter((row) => row !== null);
+    }
+    // --------------------------------------------------------------------------
+    // Trading
+    // --------------------------------------------------------------------------
+    async placeOrder(params) {
+        this.ensureAuth();
+        const apiPrivateKey = this.config?.credentials?.privateKey;
+        if (!apiPrivateKey) {
+            throw new Error("Aevo order placement requires signing key (AEVO_SIGNING_KEY)");
+        }
+        const symbol = this.normalizeSymbol(params.market);
+        const market = (await this.fetchMarkets()).find((row) => row.instrument_name === symbol);
+        if (!market) {
+            throw new Error(`Unknown Aevo market: ${params.market}`);
+        }
+        const isBuy = params.side === "long";
+        const instrument = BigInt(market.instrument_id);
+        const limitPrice = await this.resolveLimitPrice(params, symbol);
+        const amount = this.sizeToContracts(params.size, market.amount_step);
+        const limitPriceUnits = decimalToScaled(limitPrice, 6);
+        if (amount <= 0n) {
+            throw new Error(`Order size ${params.size} is below Aevo minimum step ${market.amount_step}`);
+        }
+        const account = privateKeyToAccount(apiPrivateKey);
+        const timestamp = BigInt(Math.floor(Date.now() / 1000));
+        const salt = BigInt(Date.now()) * 1000000n + BigInt(Math.floor(Math.random() * 1_000_000));
+        const signature = await account.signTypedData({
+            domain: this.config?.testnet
+                ? {
+                    name: "Aevo Testnet",
+                    version: "1",
+                    chainId: 11155111,
+                }
+                : {
+                    name: "Aevo Mainnet",
+                    version: "1",
+                    chainId: 1,
+                },
+            types: {
+                Order: [
+                    { name: "maker", type: "address" },
+                    { name: "isBuy", type: "bool" },
+                    { name: "limitPrice", type: "uint256" },
+                    { name: "amount", type: "uint256" },
+                    { name: "salt", type: "uint256" },
+                    { name: "instrument", type: "uint256" },
+                    { name: "timestamp", type: "uint256" },
+                ],
+            },
+            primaryType: "Order",
+            message: {
+                maker: account.address,
+                isBuy,
+                limitPrice: limitPriceUnits,
+                amount,
+                salt,
+                instrument,
+                timestamp,
+            },
+        });
+        const payload = {
+            instrument: instrument.toString(),
+            maker: account.address,
+            is_buy: isBuy,
+            amount: amount.toString(),
+            limit_price: limitPriceUnits.toString(),
+            salt: salt.toString(),
+            timestamp: timestamp.toString(),
+            signature,
+            post_only: params.postOnly ?? false,
+            reduce_only: params.reduceOnly ?? false,
+        };
+        const response = await this.fetchAuthed("/orders", {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+        const orderCandidate = pickObject(response, ["order", "data", "results.0"]);
+        if (orderCandidate) {
+            const mapped = this.toOrder(orderCandidate);
+            if (mapped) {
+                return mapped;
+            }
+        }
+        return {
+            id: pickString(orderCandidate ?? {}, ["order_id", "id", "client_order_id"]) ??
+                salt.toString(),
+            market: symbol,
+            side: params.side,
+            type: params.type,
+            size: params.size,
+            price: limitPrice,
+            filled: "0",
+            remaining: params.size,
+            status: "open",
+            reduceOnly: params.reduceOnly ?? false,
+            postOnly: params.postOnly ?? false,
+            timestamp: Date.now(),
+            triggerPrice: params.triggerPrice,
+        };
+    }
+    async cancelOrder(params) {
+        this.ensureAuth();
+        const orderId = params.orderId ?? params.clientOrderId;
+        if (!orderId) {
+            throw new Error("cancelOrder requires orderId or clientOrderId");
+        }
+        await this.fetchAuthed(`/orders/${encodeURIComponent(orderId)}`, {
+            method: "DELETE",
+        });
+        return true;
+    }
+    async cancelAllOrders(market) {
+        this.ensureAuth();
+        const suffix = market
+            ? `?instrument_name=${encodeURIComponent(this.normalizeSymbol(market))}`
+            : "";
+        const response = await this.fetchAuthed(`/orders-all${suffix}`, {
+            method: "DELETE",
+        });
+        const cancelled = pickNumber(response, ["cancelled", "cancelled_orders", "count"], NaN);
+        if (Number.isFinite(cancelled) && cancelled >= 0) {
+            return Math.floor(cancelled);
+        }
+        return market ? 1 : 0;
+    }
+    async setLeverage(market, leverage) {
+        this.ensureAuth();
+        const symbol = this.normalizeSymbol(market);
+        const payloads = [
+            { instrument_name: symbol, leverage },
+            { market: symbol, leverage },
+            { instrument: symbol, leverage },
+        ];
+        let lastError = null;
+        for (const payload of payloads) {
+            try {
+                await this.fetchAuthed("/account/update-margin", {
+                    method: "POST",
+                    body: JSON.stringify(payload),
+                });
+                return;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+            }
+        }
+        throw lastError ?? new Error("Failed to update Aevo leverage");
+    }
+    async setMarginType(market, type) {
+        this.ensureAuth();
+        const symbol = this.normalizeSymbol(market);
+        const payloads = [
+            { instrument_name: symbol, margin_type: type },
+            { market: symbol, margin_type: type },
+            { instrument: symbol, margin_type: type },
+            { instrument_name: symbol, type },
+        ];
+        let lastError = null;
+        for (const payload of payloads) {
+            try {
+                await this.fetchAuthed("/account/margin-type", {
+                    method: "POST",
+                    body: JSON.stringify(payload),
+                });
+                return;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+            }
+        }
+        throw lastError ?? new Error("Failed to update Aevo margin type");
+    }
+    // --------------------------------------------------------------------------
+    // Advanced Trading
+    // --------------------------------------------------------------------------
+    async modifyOrder(params) {
+        this.ensureAuth();
+        const payload = {};
+        if (params.price)
+            payload.limit_price = params.price;
+        if (params.size)
+            payload.amount = params.size;
+        if (params.triggerPrice)
+            payload.trigger_price = params.triggerPrice;
+        const response = await this.fetchAuthed(`/orders/${encodeURIComponent(params.orderId)}`, {
+            method: "PUT",
+            body: JSON.stringify(payload),
+        });
+        const orderCandidate = pickObject(response, ["order", "data", "results.0"]);
+        if (orderCandidate) {
+            const mapped = this.toOrder(orderCandidate);
+            if (mapped)
+                return mapped;
+        }
+        // Fetch back the order for full details
+        const order = await this.getOrder(params.orderId);
+        if (order)
+            return order;
+        throw new Error(`Failed to retrieve modified order ${params.orderId}`);
+    }
+    async batchPlaceOrders(paramsList) {
+        // Sequential: Aevo batch endpoint requires identical signing per-order
+        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("Aevo does not support cancelAllAfter (dead man's switch)");
+    }
+    async getOrderHistory(market, limit = 100) {
+        this.ensureAuth();
+        const query = new URLSearchParams();
+        if (market)
+            query.set("instrument_name", this.normalizeSymbol(market));
+        if (limit > 0)
+            query.set("limit", String(limit));
+        const suffix = query.size > 0 ? `?${query.toString()}` : "";
+        const response = await this.fetchAuthed(`/order-history${suffix}`);
+        const rows = pickArray(response, ["orders", "data.orders", "data.rows", "results"]);
+        return rows
+            .map((row) => this.toOrder(row))
+            .filter((row) => row !== null);
+    }
+    async getFundingHistory(market, limit = 100) {
+        this.ensureAuth();
+        const query = new URLSearchParams();
+        if (market)
+            query.set("instrument_name", this.normalizeSymbol(market));
+        if (limit > 0)
+            query.set("limit", String(limit));
+        const suffix = query.size > 0 ? `?${query.toString()}` : "";
+        const response = await this.fetchAuthed(`/funding-history${suffix}`);
+        const rows = pickArray(response, ["funding_history", "data.rows", "results"]);
+        return rows.map((row) => ({
+            market: this.normalizeSymbol(pickString(row, ["instrument_name", "market"]) ?? ""),
+            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?instrument_name=${encodeURIComponent(symbol)}&limit=${limit}`);
+        const rows = pickArray(response, ["trades", "data.trades", "results"]);
+        return rows.map((row) => ({
+            id: pickString(row, ["trade_id", "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) {
+        this.ensureAuth();
+        await this.fetchAuthed("/mmp", {
+            method: "POST",
+            body: JSON.stringify({
+                instrument_name: this.normalizeSymbol(config.market),
+                window_ms: config.windowMs,
+                frozen_ms: config.frozenMs,
+                quantity_limit: config.quantityLimit,
+                delta_limit: config.deltaLimit,
+            }),
+        });
+    }
+    async getMMP(market) {
+        this.ensureAuth();
+        const symbol = this.normalizeSymbol(market);
+        const response = await this.fetchAuthed(`/mmp?instrument_name=${encodeURIComponent(symbol)}`);
+        const data = pickObject(response, ["data", "result", "mmp"]) ?? {};
+        return {
+            market: symbol,
+            frozen: pickBoolean(data, ["frozen", "is_frozen"], false),
+            frozenUntil: pickNumber(data, ["frozen_until", "frozen_end_time"], 0) || null,
+            config: {
+                market: symbol,
+                windowMs: pickNumber(data, ["window_ms", "interval"], 0),
+                frozenMs: pickNumber(data, ["frozen_ms", "freeze_duration"], 0),
+                quantityLimit: pickString(data, ["quantity_limit", "qty_limit"]) ?? "0",
+                deltaLimit: pickString(data, ["delta_limit"]) ?? "0",
+            },
+        };
+    }
+    async resetMMP(market) {
+        this.ensureAuth();
+        const symbol = this.normalizeSymbol(market);
+        await this.fetchAuthed("/reset-mmp", {
+            method: "POST",
+            body: JSON.stringify({ instrument_name: symbol }),
+        });
+    }
+    // --------------------------------------------------------------------------
+    // TWAP Orders
+    // --------------------------------------------------------------------------
+    async placeTWAP(_params) {
+        throw new Error("Aevo TWAP orders are not supported through this adapter");
+    }
+    async cancelTWAP(_twapId) {
+        throw new Error("Aevo TWAP orders are not supported through this adapter");
+    }
+    async getTWAPStatus(_twapId) {
+        throw new Error("Aevo TWAP orders are not supported through this adapter");
+    }
+    // --------------------------------------------------------------------------
+    // Margin Management
+    // --------------------------------------------------------------------------
+    async updateIsolatedMargin(_market, _amount) {
+        throw new Error("Aevo 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 {
+                // Polling callback intentionally ignores transient read errors.
+            }
+        }, 1500);
+        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 {
+                // Polling callback intentionally ignores transient read 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("-PERP"))
+            return upper;
+        return `${upper}-PERP`;
+    }
+    ensureAuth() {
+        if (!this.config?.credentials?.apiKey || !this.config?.credentials?.apiSecret) {
+            throw new Error("Aevo authenticated endpoints require API key + secret");
+        }
+    }
+    async resolveLimitPrice(params, market) {
+        if (params.type === "market") {
+            const ticker = await this.getTicker(market);
+            const mark = parseFloat(ticker.markPrice || ticker.lastPrice);
+            if (!Number.isFinite(mark) || mark <= 0) {
+                throw new Error(`Unable to resolve Aevo market price for ${market}`);
+            }
+            const padded = params.side === "long" ? mark * 1.01 : mark * 0.99;
+            return padded.toFixed(8);
+        }
+        if (!params.price) {
+            throw new Error("Limit/triggered orders require price");
+        }
+        return params.price;
+    }
+    toOrder(row) {
+        const market = this.normalizeSymbol(pickString(row, ["instrument_name", "market", "symbol"]) ?? "");
+        if (!market)
+            return null;
+        const sideRaw = pickString(row, ["side", "direction"])?.toLowerCase() ?? "buy";
+        const side = sideRaw === "sell" || sideRaw === "short" ? "short" : "long";
+        const size = pickString(row, ["amount", "size", "quantity", "orig_qty"]) ?? "0";
+        const filled = pickString(row, ["filled_amount", "filled", "executed_quantity"]) ?? "0";
+        const remaining = pickString(row, ["remaining_amount", "remaining", "leaves_qty"]) ??
+            Math.max(0, parseFloat(size) - parseFloat(filled)).toString();
+        const statusRaw = pickString(row, ["status", "order_status"])?.toLowerCase() ?? "open";
+        const status = statusRaw.includes("cancel")
+            ? "cancelled"
+            : statusRaw.includes("fill")
+                ? parseFloat(remaining) > 0
+                    ? "partial"
+                    : "filled"
+                : statusRaw.includes("expire")
+                    ? "expired"
+                    : "open";
+        const typeRaw = pickString(row, ["order_type", "type"])?.toLowerCase() ?? "limit";
+        const type = typeRaw.includes("market")
+            ? "market"
+            : typeRaw.includes("stop") && typeRaw.includes("limit")
+                ? "stop_limit"
+                : typeRaw.includes("stop")
+                    ? "stop"
+                    : typeRaw.includes("take")
+                        ? "take_profit"
+                        : "limit";
+        return {
+            id: pickString(row, ["order_id", "id", "client_order_id", "uuid"]) ??
+                `${market}-${Date.now()}`,
+            market,
+            side,
+            type,
+            size,
+            price: pickString(row, ["limit_price", "price", "avg_price"]),
+            filled,
+            remaining,
+            status,
+            reduceOnly: pickBoolean(row, ["reduce_only", "reduceOnly"], false),
+            postOnly: pickBoolean(row, ["post_only", "postOnly"], false),
+            timestamp: toTimestampMs(pickUnknown(row, ["created_at", "timestamp", "updated_at"]), Date.now()),
+            triggerPrice: pickString(row, ["trigger_price"]) ?? undefined,
+        };
+    }
+    sizeToContracts(size, amountStep) {
+        const stepDecimals = decimalPlaces(amountStep);
+        const sizeScaled = decimalToScaled(size, stepDecimals);
+        const stepScaled = decimalToScaled(amountStep, stepDecimals);
+        if (stepScaled <= 0n) {
+            throw new Error(`Invalid Aevo amount_step ${amountStep}`);
+        }
+        return sizeScaled / stepScaled;
+    }
+}
+// Register the adapter
+registerAdapter("aevo", () => new AevoAdapter());
+export default AevoAdapter;