@raintree-technology/perps 0.1.0

package/dist/commands/data/index.js

@@ -0,0 +1,1466 @@
+import ccxt from "ccxt";
+import pmxt from "pmxtjs";
+import { getOutputOptions } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+const PMXT_EXCHANGES = {
+    polymarket: "Polymarket",
+    kalshi: "Kalshi",
+    limitless: "Limitless",
+};
+const BOOLEAN_TRUE_VALUES = new Set(["1", "true", "yes", "on"]);
+const BOOLEAN_FALSE_VALUES = new Set(["0", "false", "no", "off"]);
+const FUTURES_METHOD_PATTERN = /(?:future|futures|swap|contract|perp|position|funding|openinterest|open_interest|leverage|margin|order|transfer|liquidation|settlement|trigger|takeprofit|take_profit|stop|hedge|adl|insurance|risk|borrow|repay)/i;
+const LIKELY_ONCHAIN_EXCHANGE_IDS = new Set([
+    "aevo",
+    "dydx",
+    "dydxv3",
+    "dydxv4",
+    "drift",
+    "gmx",
+    "gmxv2",
+    "hyperliquid",
+    "injective",
+    "jupiter",
+    "kwenta",
+    "mango",
+    "paradex",
+    "perpetual-protocol",
+    "polkadex",
+    "synthetix",
+    "uniswap",
+    "vertex",
+    "zeta",
+]);
+const FUTURES_OPERATION_ALIASES = {
+    book: "orderbook",
+    "order-book": "orderbook",
+    funding: "funding-rate",
+    fundingrate: "funding-rate",
+    fundingrates: "funding-rates",
+    "funding-history": "funding-history",
+    "funding-rate-history": "funding-rate-history",
+    openinterest: "open-interest",
+    openinterests: "open-interests",
+    "open-interest-history": "open-interest-history",
+    "open-orders": "orders-open",
+    "closed-orders": "orders-closed",
+    "canceled-orders": "orders-canceled",
+    trades: "my-trades",
+    trade: "my-trades",
+    methods: "futures-methods",
+    leverageinfo: "leverage",
+    leveragetiers: "leverage-tiers",
+    "market-leverage": "market-leverage-tiers",
+    "set-margin": "set-margin-mode",
+    "set-position": "set-position-mode",
+    "position-history": "position-history",
+    "positions-history": "positions-history",
+    "positions-risk": "positions-risk",
+    "public-trades": "trades-public",
+    transferin: "transfer-in",
+    transferout: "transfer-out",
+    "add-collateral": "add-margin",
+    "reduce-collateral": "reduce-margin",
+    borrow: "borrow-margin",
+    repay: "repay-margin",
+    closeposition: "close-position",
+    closeallpositions: "close-all-positions",
+};
+const SUPPORTED_FUTURES_OPERATIONS = [
+    "markets",
+    "ticker",
+    "tickers",
+    "orderbook",
+    "funding-rate",
+    "funding-rates",
+    "funding-rate-history",
+    "funding-history",
+    "open-interest",
+    "open-interests",
+    "open-interest-history",
+    "balance",
+    "positions",
+    "position",
+    "positions-history",
+    "position-history",
+    "positions-risk",
+    "account-positions",
+    "option-positions",
+    "orders-open",
+    "orders",
+    "orders-closed",
+    "orders-canceled",
+    "order",
+    "order-trades",
+    "my-trades",
+    "trades-public",
+    "create-order",
+    "cancel-order",
+    "cancel-all",
+    "set-leverage",
+    "set-margin-mode",
+    "set-position-mode",
+    "leverage",
+    "leverage-tiers",
+    "market-leverage-tiers",
+    "margin-mode",
+    "position-mode",
+    "margin-adjustment-history",
+    "transfers",
+    "transfer",
+    "transfer-in",
+    "transfer-out",
+    "add-margin",
+    "reduce-margin",
+    "borrow-margin",
+    "repay-margin",
+    "close-position",
+    "close-all-positions",
+    "snapshot",
+    "futures-methods",
+    "raw",
+];
+const FUTURES_OPERATION_METHOD_HINTS = {
+    markets: ["fetchMarkets"],
+    ticker: ["fetchTicker"],
+    tickers: ["fetchTickers"],
+    orderbook: ["fetchOrderBook"],
+    "funding-rate": ["fetchFundingRate"],
+    "funding-rates": ["fetchFundingRates", "fetchFundingRate"],
+    "funding-rate-history": ["fetchFundingRateHistory"],
+    "funding-history": ["fetchFundingHistory"],
+    "open-interest": ["fetchOpenInterest"],
+    "open-interests": ["fetchOpenInterests", "fetchOpenInterest"],
+    "open-interest-history": ["fetchOpenInterestHistory"],
+    balance: ["fetchBalance"],
+    positions: ["fetchPositions", "fetchPosition", "fetchAccountPositions", "fetchPositionsRisk"],
+    position: ["fetchPosition", "fetchPositions", "fetchPositionsForSymbol"],
+    "positions-history": ["fetchPositionsHistory", "fetchPositionHistory"],
+    "position-history": ["fetchPositionHistory"],
+    "positions-risk": ["fetchPositionsRisk", "fetchPositions"],
+    "account-positions": ["fetchAccountPositions", "fetchPositions"],
+    "option-positions": ["fetchOptionPositions"],
+    "orders-open": ["fetchOpenOrders"],
+    orders: ["fetchOrders"],
+    "orders-closed": ["fetchClosedOrders"],
+    "orders-canceled": ["fetchCanceledOrders"],
+    order: ["fetchOrder"],
+    "order-trades": ["fetchOrderTrades"],
+    "my-trades": ["fetchMyTrades"],
+    "trades-public": ["fetchTrades"],
+    "create-order": ["createOrder"],
+    "cancel-order": ["cancelOrder"],
+    "cancel-all": ["cancelAllOrders"],
+    "set-leverage": ["setLeverage"],
+    "set-margin-mode": ["setMarginMode"],
+    "set-position-mode": ["setPositionMode"],
+    leverage: ["fetchLeverage", "fetchLeverages"],
+    "leverage-tiers": ["fetchLeverageTiers", "fetchMarketLeverageTiers"],
+    "market-leverage-tiers": ["fetchMarketLeverageTiers"],
+    "margin-mode": ["fetchMarginMode", "fetchMarginModes"],
+    "position-mode": ["fetchPositionMode"],
+    "margin-adjustment-history": ["fetchMarginAdjustmentHistory"],
+    transfers: ["fetchTransfers"],
+    transfer: ["transfer"],
+    "transfer-in": ["transferIn", "transfer"],
+    "transfer-out": ["transferOut", "transfer"],
+    "add-margin": ["addMargin"],
+    "reduce-margin": ["reduceMargin"],
+    "borrow-margin": ["borrowMargin"],
+    "repay-margin": ["repayMargin"],
+    "close-position": ["closePosition"],
+    "close-all-positions": ["closeAllPositions"],
+    snapshot: ["fetchMarkets", "fetchPositions", "fetchBalance", "fetchOpenOrders"],
+    "futures-methods": [],
+    raw: [],
+};
+function asRecord(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    return value;
+}
+function parseBooleanLike(raw, label) {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized.length === 0)
+        return undefined;
+    if (BOOLEAN_TRUE_VALUES.has(normalized))
+        return true;
+    if (BOOLEAN_FALSE_VALUES.has(normalized))
+        return false;
+    throw new Error(`${label} must be one of: ${Array.from(BOOLEAN_TRUE_VALUES).join(", ")} or ${Array.from(BOOLEAN_FALSE_VALUES).join(", ")}`);
+}
+function parseNumber(raw, label) {
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        throw new Error(`${label} must be a finite number`);
+    }
+    return value;
+}
+function parseOptionalNumber(raw, label) {
+    if (!raw)
+        return undefined;
+    return parseNumber(raw, label);
+}
+function parseOptionalPositiveNumber(raw, label) {
+    const value = parseOptionalNumber(raw, label);
+    if (value === undefined)
+        return undefined;
+    if (value <= 0) {
+        throw new Error(`${label} must be a positive number`);
+    }
+    return value;
+}
+function parseOptionalInteger(raw, label) {
+    const value = parseOptionalNumber(raw, label);
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value)) {
+        throw new Error(`${label} must be an integer`);
+    }
+    return value;
+}
+function normalizeOptionalString(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+export function parseJsonArray(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            throw new Error("must be a JSON array");
+        }
+        return parsed;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid --args JSON: ${reason}. Example: --args '["BTC/USDT"]'`);
+    }
+}
+export function parseJsonObject(raw, label = "--params") {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new Error("must be a JSON object");
+        }
+        return parsed;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid ${label} JSON: ${reason}. Example: ${label} '{"recvWindow":5000}'`);
+    }
+}
+function parseJsonStringArray(raw, label) {
+    const values = parseJsonArray(raw);
+    const invalid = values.find((item) => typeof item !== "string");
+    if (invalid !== undefined) {
+        throw new Error(`${label} must be a JSON array of strings`);
+    }
+    return values;
+}
+function parseEnvJsonObject(name) {
+    const raw = process.env[name];
+    if (!raw || raw.trim().length === 0)
+        return undefined;
+    return parseJsonObject(raw, `env ${name}`);
+}
+function parseEnvInt(name) {
+    const raw = process.env[name];
+    if (!raw || raw.trim().length === 0)
+        return undefined;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+    return value;
+}
+function isEmptyObject(value) {
+    return !value || Object.keys(value).length === 0;
+}
+function mergeObjects(...objects) {
+    const out = {};
+    for (const item of objects) {
+        if (!item)
+            continue;
+        for (const [key, value] of Object.entries(item)) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function trimTrailingUndefined(args) {
+    const values = [...args];
+    while (values.length > 0 && values[values.length - 1] === undefined) {
+        values.pop();
+    }
+    return values;
+}
+function isCcxtMethodAvailable(instance, method) {
+    return typeof instance[method] === "function";
+}
+function listFuturesMethods(instance) {
+    return listCallableMethods(instance).filter((method) => FUTURES_METHOD_PATTERN.test(method));
+}
+function listCcxtExchangeIds() {
+    const exchangeList = ccxt.exchanges;
+    if (Array.isArray(exchangeList) && exchangeList.length > 0) {
+        return [...exchangeList].sort();
+    }
+    const constructors = ccxt;
+    return Object.keys(constructors)
+        .filter((name) => !name.startsWith("_") && /^[a-z0-9]+$/.test(name) && typeof constructors[name] === "function" && constructors[name].prototype?.id !== undefined)
+        .sort();
+}
+function resolveOperation(operationRaw) {
+    const operation = operationRaw.toLowerCase().replace(/_/g, "-");
+    return FUTURES_OPERATION_ALIASES[operation] ?? operation;
+}
+function requireString(value, label) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized) {
+        throw new Error(`${label} is required`);
+    }
+    return normalized;
+}
+function requireNumber(value, label) {
+    if (value === undefined) {
+        throw new Error(`${label} is required`);
+    }
+    return value;
+}
+function parsePositionMode(value) {
+    const normalized = requireString(value, "--position-mode").toLowerCase();
+    if (["hedged", "hedge", "true", "on", "1"].includes(normalized)) {
+        return true;
+    }
+    if (["oneway", "one-way", "false", "off", "0"].includes(normalized)) {
+        return false;
+    }
+    throw new Error("--position-mode must be one of: hedged, oneway");
+}
+function isNotSupportedError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const text = `${err.name} ${err.message}`.toLowerCase();
+    return text.includes("not supported") || text.includes("unsupported") || text.includes("not implemented");
+}
+async function callWithFallback(instance, attempts, context) {
+    const available = attempts.filter((attempt) => isCcxtMethodAvailable(instance, attempt.method));
+    if (available.length === 0) {
+        throw new Error(`No supported method for ${context}. None of these methods are available: ${attempts
+            .map((attempt) => attempt.method)
+            .join(", ")}`);
+    }
+    let lastUnsupportedError = null;
+    for (const attempt of available) {
+        try {
+            return await callMethod(instance, attempt.method, trimTrailingUndefined(attempt.args));
+        }
+        catch (err) {
+            if (isNotSupportedError(err)) {
+                lastUnsupportedError = err instanceof Error ? err : new Error(String(err));
+                continue;
+            }
+            throw err;
+        }
+    }
+    if (lastUnsupportedError) {
+        throw new Error(`No supported method for ${context}. Tried: ${available.map((attempt) => attempt.method).join(", ")}. Last error: ${lastUnsupportedError.message}`);
+    }
+    throw new Error(`No supported method for ${context}. Tried: ${available.map((attempt) => attempt.method).join(", ")}`);
+}
+function normalizeToObjectArray(data) {
+    if (!Array.isArray(data))
+        return [];
+    return data
+        .map((item) => asRecord(item))
+        .filter((item) => item !== null);
+}
+function isSupportedFlag(value) {
+    return value === true || value === "emulated";
+}
+function deriveDerivativeSupport(hasMap) {
+    const supportsPerpsOrFutures = isSupportedFlag(hasMap.fetchPositions) ||
+        isSupportedFlag(hasMap.fetchFundingRate) ||
+        isSupportedFlag(hasMap.fetchOpenInterest) ||
+        isSupportedFlag(hasMap.setLeverage) ||
+        hasMap.swap === true ||
+        hasMap.future === true;
+    return {
+        perpsOrFutures: supportsPerpsOrFutures,
+        positions: isSupportedFlag(hasMap.fetchPositions),
+        funding: isSupportedFlag(hasMap.fetchFundingRate),
+        openInterest: isSupportedFlag(hasMap.fetchOpenInterest),
+        leverageControl: isSupportedFlag(hasMap.setLeverage),
+        marginModeControl: isSupportedFlag(hasMap.setMarginMode),
+        positionModeControl: isSupportedFlag(hasMap.setPositionMode),
+        transfers: isSupportedFlag(hasMap.fetchTransfers),
+        swapMarkets: hasMap.swap === true,
+        futureMarkets: hasMap.future === true,
+        optionsMarkets: hasMap.option === true,
+    };
+}
+function inferVenueType(exchangeId) {
+    const id = exchangeId.toLowerCase();
+    if (LIKELY_ONCHAIN_EXCHANGE_IDS.has(id)) {
+        return { venue: "onchain_or_hybrid", reason: "known on-chain or hybrid venue id" };
+    }
+    if (id.includes("defi") || id.includes("swap")) {
+        return { venue: "onchain_or_hybrid", reason: "exchange id suggests DEX/DeFi routing" };
+    }
+    return { venue: "offchain_or_hybrid", reason: "default classification (most CCXT venues are off-chain orderbooks)" };
+}
+function inferAuthModel(requiredCredentials) {
+    const apiKey = requiredCredentials.apiKey === true || requiredCredentials.secret === true;
+    const wallet = requiredCredentials.privateKey === true || requiredCredentials.walletAddress === true;
+    if (apiKey && wallet)
+        return "hybrid";
+    if (wallet)
+        return "wallet";
+    if (apiKey)
+        return "api_key";
+    return "optional_or_unknown";
+}
+function buildMarketStats(instance) {
+    const markets = asRecord(instance.markets);
+    if (!markets) {
+        return {
+            loaded: false,
+            total: 0,
+        };
+    }
+    let total = 0;
+    let active = 0;
+    let inactive = 0;
+    let spot = 0;
+    let contract = 0;
+    let swap = 0;
+    let future = 0;
+    let option = 0;
+    let linear = 0;
+    let inverse = 0;
+    const settleAssets = new Set();
+    const quoteAssets = new Set();
+    const baseAssets = new Set();
+    const sample = new Set();
+    for (const [fallbackSymbol, value] of Object.entries(markets)) {
+        const market = asRecord(value);
+        if (!market)
+            continue;
+        total += 1;
+        if (market.active === true)
+            active += 1;
+        if (market.active === false)
+            inactive += 1;
+        if (market.spot === true)
+            spot += 1;
+        if (market.contract === true)
+            contract += 1;
+        if (market.swap === true)
+            swap += 1;
+        if (market.future === true)
+            future += 1;
+        if (market.option === true)
+            option += 1;
+        if (market.linear === true)
+            linear += 1;
+        if (market.inverse === true)
+            inverse += 1;
+        if (typeof market.settle === "string")
+            settleAssets.add(market.settle);
+        if (typeof market.quote === "string")
+            quoteAssets.add(market.quote);
+        if (typeof market.base === "string")
+            baseAssets.add(market.base);
+        const symbol = typeof market.symbol === "string" ? market.symbol : fallbackSymbol;
+        if (symbol.length > 0 && sample.size < 20) {
+            sample.add(symbol);
+        }
+    }
+    return {
+        loaded: true,
+        total,
+        active,
+        inactive,
+        spot,
+        contract,
+        swap,
+        future,
+        option,
+        linear,
+        inverse,
+        settleAssets: [...settleAssets].sort(),
+        quoteAssets: [...quoteAssets].sort(),
+        baseAssets: [...baseAssets].sort(),
+        sampleSymbols: [...sample],
+    };
+}
+function buildCurrencyStats(instance) {
+    const currencies = asRecord(instance.currencies);
+    if (!currencies) {
+        return {
+            loaded: false,
+            total: 0,
+        };
+    }
+    let total = 0;
+    let active = 0;
+    let inactive = 0;
+    const sample = new Set();
+    for (const [code, value] of Object.entries(currencies)) {
+        const currency = asRecord(value);
+        if (!currency)
+            continue;
+        total += 1;
+        if (currency.active === true)
+            active += 1;
+        if (currency.active === false)
+            inactive += 1;
+        if (sample.size < 30)
+            sample.add(code);
+    }
+    return {
+        loaded: true,
+        total,
+        active,
+        inactive,
+        sampleCodes: [...sample],
+    };
+}
+function buildFuturesOperationSupport(instance) {
+    const methods = new Set(listCallableMethods(instance));
+    const support = {};
+    for (const operation of SUPPORTED_FUTURES_OPERATIONS) {
+        if (operation === "raw" || operation === "futures-methods") {
+            support[operation] = {
+                supported: true,
+                via: operation === "raw" ? ["any callable method"] : ["method filtering"],
+            };
+            continue;
+        }
+        const hints = FUTURES_OPERATION_METHOD_HINTS[operation];
+        const available = hints.filter((method) => methods.has(method));
+        support[operation] = {
+            supported: available.length > 0,
+            via: available,
+            hintMethods: hints,
+        };
+    }
+    return support;
+}
+function toErrorMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+async function executeBestEffortSnapshot(instance, input) {
+    const params = input.params ?? {};
+    const tasks = [
+        {
+            key: "markets",
+            run: async () => {
+                const markets = await callWithFallback(instance, [{ method: "fetchMarkets", args: [params] }], "snapshot.markets");
+                const normalized = normalizeToObjectArray(markets);
+                const contracts = normalized.filter((market) => market.contract === true || market.swap === true || market.future === true);
+                return contracts.length > 0 ? contracts : markets;
+            },
+        },
+        {
+            key: "balance",
+            run: async () => callWithFallback(instance, [{ method: "fetchBalance", args: [params] }], "snapshot.balance"),
+        },
+        {
+            key: "positions",
+            run: async () => callWithFallback(instance, [
+                { method: "fetchPositions", args: [input.symbols, params] },
+                { method: "fetchAccountPositions", args: [input.symbols, params] },
+            ], "snapshot.positions"),
+        },
+        {
+            key: "openOrders",
+            run: async () => callWithFallback(instance, [{ method: "fetchOpenOrders", args: [input.symbol, input.since, input.limit, params] }], "snapshot.openOrders"),
+        },
+        {
+            key: "ticker",
+            run: async () => {
+                if (input.symbol) {
+                    return callWithFallback(instance, [{ method: "fetchTicker", args: [input.symbol, params] }], "snapshot.ticker");
+                }
+                return callWithFallback(instance, [{ method: "fetchTickers", args: [input.symbols, params] }], "snapshot.tickers");
+            },
+        },
+        {
+            key: "funding",
+            run: async () => {
+                if (input.symbol) {
+                    return callWithFallback(instance, [{ method: "fetchFundingRate", args: [input.symbol, params] }], "snapshot.fundingRate");
+                }
+                return callWithFallback(instance, [{ method: "fetchFundingRates", args: [input.symbols, params] }], "snapshot.fundingRates");
+            },
+        },
+        {
+            key: "openInterest",
+            run: async () => {
+                if (input.symbol) {
+                    return callWithFallback(instance, [{ method: "fetchOpenInterest", args: [input.symbol, params] }], "snapshot.openInterest");
+                }
+                return callWithFallback(instance, [{ method: "fetchOpenInterests", args: [input.symbols, params] }], "snapshot.openInterests");
+            },
+        },
+    ];
+    const data = {};
+    const errors = {};
+    for (const task of tasks) {
+        try {
+            data[task.key] = await task.run();
+        }
+        catch (err) {
+            errors[task.key] = toErrorMessage(err);
+        }
+    }
+    return {
+        timestamp: Date.now(),
+        symbol: input.symbol ?? null,
+        symbols: input.symbols ?? null,
+        data,
+        errors,
+    };
+}
+export async function executeCcxtFuturesOperation(instance, operationRaw, input) {
+    const operation = resolveOperation(operationRaw);
+    if (!SUPPORTED_FUTURES_OPERATIONS.includes(operation)) {
+        throw new Error(`Unsupported futures operation '${operationRaw}'. Supported operations: ${SUPPORTED_FUTURES_OPERATIONS.join(", ")}`);
+    }
+    const params = input.params ?? {};
+    switch (operation) {
+        case "markets": {
+            const result = await callWithFallback(instance, [{ method: "fetchMarkets", args: [params] }], "markets");
+            const normalized = normalizeToObjectArray(result);
+            if (normalized.length === 0)
+                return result;
+            const futures = normalized.filter((market) => market.contract === true || market.swap === true || market.future === true);
+            return futures.length > 0 ? futures : result;
+        }
+        case "ticker": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchTicker", args: [symbol, params] }], "ticker");
+        }
+        case "tickers": {
+            return callWithFallback(instance, [{ method: "fetchTickers", args: [input.symbols, params] }], "tickers");
+        }
+        case "orderbook": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchOrderBook", args: [symbol, input.limit, params] }], "orderbook");
+        }
+        case "funding-rate": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchFundingRate", args: [symbol, params] }], "funding-rate");
+        }
+        case "funding-rates": {
+            if (input.symbol && !input.symbols) {
+                return callWithFallback(instance, [{ method: "fetchFundingRate", args: [input.symbol, params] }], "funding-rates");
+            }
+            return callWithFallback(instance, [{ method: "fetchFundingRates", args: [input.symbols, params] }], "funding-rates");
+        }
+        case "funding-rate-history": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchFundingRateHistory", args: [symbol, input.since, input.limit, params] }], "funding-rate-history");
+        }
+        case "funding-history": {
+            return callWithFallback(instance, [{ method: "fetchFundingHistory", args: [input.symbol, input.since, input.limit, params] }], "funding-history");
+        }
+        case "open-interest": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchOpenInterest", args: [symbol, params] }], "open-interest");
+        }
+        case "open-interests": {
+            if (input.symbol && !input.symbols) {
+                return callWithFallback(instance, [{ method: "fetchOpenInterest", args: [input.symbol, params] }], "open-interests");
+            }
+            return callWithFallback(instance, [{ method: "fetchOpenInterests", args: [input.symbols, params] }], "open-interests");
+        }
+        case "open-interest-history": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchOpenInterestHistory", args: [symbol, input.since, input.limit, params] }], "open-interest-history");
+        }
+        case "balance": {
+            return callWithFallback(instance, [{ method: "fetchBalance", args: [params] }], "balance");
+        }
+        case "positions": {
+            if (input.symbol) {
+                return callWithFallback(instance, [
+                    { method: "fetchPosition", args: [input.symbol, params] },
+                    { method: "fetchPositionsForSymbol", args: [input.symbol, params] },
+                    { method: "fetchPositions", args: [[input.symbol], params] },
+                    { method: "fetchAccountPositions", args: [[input.symbol], params] },
+                ], "positions");
+            }
+            return callWithFallback(instance, [
+                { method: "fetchPositions", args: [input.symbols, params] },
+                { method: "fetchAccountPositions", args: [input.symbols, params] },
+                { method: "fetchPositionsRisk", args: [input.symbols, params] },
+            ], "positions");
+        }
+        case "position": {
+            const symbol = requireString(input.symbol, "--symbol");
+            const result = await callWithFallback(instance, [
+                { method: "fetchPosition", args: [symbol, params] },
+                { method: "fetchPositionsForSymbol", args: [symbol, params] },
+                { method: "fetchPositions", args: [[symbol], params] },
+            ], "position");
+            if (Array.isArray(result)) {
+                return result[0] ?? null;
+            }
+            return result;
+        }
+        case "positions-history": {
+            if (input.symbol) {
+                return callWithFallback(instance, [
+                    { method: "fetchPositionHistory", args: [input.symbol, input.since, input.limit, params] },
+                    { method: "fetchPositionsHistory", args: [[input.symbol], input.since, input.limit, params] },
+                ], "positions-history");
+            }
+            return callWithFallback(instance, [{ method: "fetchPositionsHistory", args: [input.symbols, input.since, input.limit, params] }], "positions-history");
+        }
+        case "position-history": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchPositionHistory", args: [symbol, input.since, input.limit, params] }], "position-history");
+        }
+        case "positions-risk": {
+            return callWithFallback(instance, [
+                { method: "fetchPositionsRisk", args: [input.symbols, params] },
+                { method: "fetchPositions", args: [input.symbols, params] },
+            ], "positions-risk");
+        }
+        case "account-positions": {
+            return callWithFallback(instance, [
+                { method: "fetchAccountPositions", args: [input.symbols, params] },
+                { method: "fetchPositions", args: [input.symbols, params] },
+            ], "account-positions");
+        }
+        case "option-positions": {
+            return callWithFallback(instance, [{ method: "fetchOptionPositions", args: [input.symbols, params] }], "option-positions");
+        }
+        case "orders-open": {
+            return callWithFallback(instance, [{ method: "fetchOpenOrders", args: [input.symbol, input.since, input.limit, params] }], "orders-open");
+        }
+        case "orders": {
+            return callWithFallback(instance, [{ method: "fetchOrders", args: [input.symbol, input.since, input.limit, params] }], "orders");
+        }
+        case "orders-closed": {
+            return callWithFallback(instance, [{ method: "fetchClosedOrders", args: [input.symbol, input.since, input.limit, params] }], "orders-closed");
+        }
+        case "orders-canceled": {
+            return callWithFallback(instance, [{ method: "fetchCanceledOrders", args: [input.symbol, input.since, input.limit, params] }], "orders-canceled");
+        }
+        case "order": {
+            const id = requireString(input.id, "--id");
+            return callWithFallback(instance, [{ method: "fetchOrder", args: [id, input.symbol, params] }], "order");
+        }
+        case "order-trades": {
+            const id = requireString(input.id, "--id");
+            return callWithFallback(instance, [{ method: "fetchOrderTrades", args: [id, input.symbol, input.since, input.limit, params] }], "order-trades");
+        }
+        case "my-trades": {
+            return callWithFallback(instance, [{ method: "fetchMyTrades", args: [input.symbol, input.since, input.limit, params] }], "my-trades");
+        }
+        case "trades-public": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchTrades", args: [symbol, input.since, input.limit, params] }], "trades-public");
+        }
+        case "create-order": {
+            const symbol = requireString(input.symbol, "--symbol");
+            const side = requireString(input.side, "--side").toLowerCase();
+            const orderType = requireString(input.orderType, "--order-type").toLowerCase();
+            const amount = requireNumber(input.amount, "--amount");
+            if (!["buy", "sell"].includes(side)) {
+                throw new Error("--side must be buy or sell");
+            }
+            if (orderType === "limit" && input.price === undefined) {
+                throw new Error("--price is required when --order-type is limit");
+            }
+            return callWithFallback(instance, [{ method: "createOrder", args: [symbol, orderType, side, amount, input.price, params] }], "create-order");
+        }
+        case "cancel-order": {
+            const id = requireString(input.id, "--id");
+            return callWithFallback(instance, [{ method: "cancelOrder", args: [id, input.symbol, params] }], "cancel-order");
+        }
+        case "cancel-all": {
+            return callWithFallback(instance, [{ method: "cancelAllOrders", args: [input.symbol, params] }], "cancel-all");
+        }
+        case "set-leverage": {
+            const symbol = requireString(input.symbol, "--symbol");
+            const leverage = requireNumber(input.leverage, "--leverage");
+            if (leverage <= 0) {
+                throw new Error("--leverage must be a positive number");
+            }
+            return callWithFallback(instance, [{ method: "setLeverage", args: [leverage, symbol, params] }], "set-leverage");
+        }
+        case "set-margin-mode": {
+            const symbol = requireString(input.symbol, "--symbol");
+            const marginMode = requireString(input.marginMode, "--margin-mode");
+            return callWithFallback(instance, [{ method: "setMarginMode", args: [marginMode, symbol, params] }], "set-margin-mode");
+        }
+        case "set-position-mode": {
+            const hedged = parsePositionMode(input.positionMode);
+            return callWithFallback(instance, [
+                { method: "setPositionMode", args: [hedged, input.symbol, params] },
+                { method: "setPositionMode", args: [hedged, params] },
+            ], "set-position-mode");
+        }
+        case "leverage": {
+            if (input.symbol) {
+                const result = await callWithFallback(instance, [
+                    { method: "fetchLeverage", args: [input.symbol, params] },
+                    { method: "fetchLeverages", args: [[input.symbol], params] },
+                ], "leverage");
+                if (Array.isArray(result)) {
+                    return result[0] ?? null;
+                }
+                return result;
+            }
+            return callWithFallback(instance, [{ method: "fetchLeverages", args: [input.symbols, params] }], "leverage");
+        }
+        case "leverage-tiers": {
+            if (input.symbol) {
+                return callWithFallback(instance, [
+                    { method: "fetchMarketLeverageTiers", args: [input.symbol, params] },
+                    { method: "fetchLeverageTiers", args: [[input.symbol], params] },
+                ], "leverage-tiers");
+            }
+            return callWithFallback(instance, [{ method: "fetchLeverageTiers", args: [input.symbols, params] }], "leverage-tiers");
+        }
+        case "market-leverage-tiers": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchMarketLeverageTiers", args: [symbol, params] }], "market-leverage-tiers");
+        }
+        case "margin-mode": {
+            if (input.symbol) {
+                const result = await callWithFallback(instance, [
+                    { method: "fetchMarginMode", args: [input.symbol, params] },
+                    { method: "fetchMarginModes", args: [[input.symbol], params] },
+                ], "margin-mode");
+                if (Array.isArray(result)) {
+                    return result[0] ?? null;
+                }
+                return result;
+            }
+            return callWithFallback(instance, [{ method: "fetchMarginModes", args: [input.symbols, params] }], "margin-mode");
+        }
+        case "position-mode": {
+            return callWithFallback(instance, [{ method: "fetchPositionMode", args: [input.symbol, params] }], "position-mode");
+        }
+        case "margin-adjustment-history": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [{ method: "fetchMarginAdjustmentHistory", args: [symbol, input.since, input.limit, params] }], "margin-adjustment-history");
+        }
+        case "transfers": {
+            return callWithFallback(instance, [{ method: "fetchTransfers", args: [input.code, input.since, input.limit, params] }], "transfers");
+        }
+        case "transfer": {
+            const code = requireString(input.code, "--code");
+            const amount = requireNumber(input.amount, "--amount");
+            const fromAccount = requireString(input.from, "--from");
+            const toAccount = requireString(input.to, "--to");
+            if (amount <= 0) {
+                throw new Error("--amount must be a positive number");
+            }
+            return callWithFallback(instance, [{ method: "transfer", args: [code, amount, fromAccount, toAccount, params] }], "transfer");
+        }
+        case "transfer-in": {
+            const code = requireString(input.code, "--code");
+            const amount = requireNumber(input.amount, "--amount");
+            const fromAccount = input.from ?? "spot";
+            const toAccount = input.to ?? "swap";
+            if (amount <= 0) {
+                throw new Error("--amount must be a positive number");
+            }
+            return callWithFallback(instance, [
+                { method: "transferIn", args: [code, amount, params] },
+                { method: "transfer", args: [code, amount, fromAccount, toAccount, params] },
+            ], "transfer-in");
+        }
+        case "transfer-out": {
+            const code = requireString(input.code, "--code");
+            const amount = requireNumber(input.amount, "--amount");
+            const fromAccount = input.from ?? "swap";
+            const toAccount = input.to ?? "spot";
+            if (amount <= 0) {
+                throw new Error("--amount must be a positive number");
+            }
+            return callWithFallback(instance, [
+                { method: "transferOut", args: [code, amount, params] },
+                { method: "transfer", args: [code, amount, fromAccount, toAccount, params] },
+            ], "transfer-out");
+        }
+        case "add-margin": {
+            const symbol = requireString(input.symbol, "--symbol");
+            const amount = requireNumber(input.amount, "--amount");
+            if (amount <= 0) {
+                throw new Error("--amount must be a positive number");
+            }
+            return callWithFallback(instance, [{ method: "addMargin", args: [symbol, amount, params] }], "add-margin");
+        }
+        case "reduce-margin": {
+            const symbol = requireString(input.symbol, "--symbol");
+            const amount = requireNumber(input.amount, "--amount");
+            if (amount <= 0) {
+                throw new Error("--amount must be a positive number");
+            }
+            return callWithFallback(instance, [{ method: "reduceMargin", args: [symbol, amount, params] }], "reduce-margin");
+        }
+        case "borrow-margin": {
+            const code = requireString(input.code, "--code");
+            const amount = requireNumber(input.amount, "--amount");
+            if (amount <= 0) {
+                throw new Error("--amount must be a positive number");
+            }
+            return callWithFallback(instance, [{ method: "borrowMargin", args: [code, amount, input.symbol, params] }], "borrow-margin");
+        }
+        case "repay-margin": {
+            const code = requireString(input.code, "--code");
+            const amount = requireNumber(input.amount, "--amount");
+            if (amount <= 0) {
+                throw new Error("--amount must be a positive number");
+            }
+            return callWithFallback(instance, [{ method: "repayMargin", args: [code, amount, input.symbol, params] }], "repay-margin");
+        }
+        case "close-position": {
+            const symbol = requireString(input.symbol, "--symbol");
+            return callWithFallback(instance, [
+                { method: "closePosition", args: [symbol, input.side, params] },
+                { method: "closePosition", args: [symbol, params] },
+            ], "close-position");
+        }
+        case "close-all-positions": {
+            return callWithFallback(instance, [{ method: "closeAllPositions", args: [params] }], "close-all-positions");
+        }
+        case "snapshot": {
+            return executeBestEffortSnapshot(instance, input);
+        }
+        case "futures-methods": {
+            return listFuturesMethods(instance);
+        }
+        case "raw": {
+            const method = requireString(input.rawMethod, "--raw-method");
+            return callMethod(instance, method, input.rawArgs);
+        }
+    }
+}
+function buildCcxtClient(exchangeId, buildOptions = {}) {
+    const constructors = ccxt;
+    const normalized = exchangeId.toLowerCase();
+    const ExchangeCtor = constructors[normalized];
+    if (!ExchangeCtor) {
+        const supported = listCcxtExchangeIds().slice(0, 40).join(", ");
+        throw new Error(`Unknown ccxt exchange '${exchangeId}'. Try one of: ${supported} ...`);
+    }
+    const envOptions = parseEnvJsonObject("CCXT_OPTIONS");
+    const envHeaders = parseEnvJsonObject("CCXT_HEADERS");
+    const envHedged = parseBooleanLike(process.env.CCXT_HEDGED, "CCXT_HEDGED");
+    const envVerbose = parseBooleanLike(process.env.CCXT_VERBOSE, "CCXT_VERBOSE");
+    const envEnableRateLimit = parseBooleanLike(process.env.CCXT_ENABLE_RATE_LIMIT, "CCXT_ENABLE_RATE_LIMIT");
+    const envTimeout = parseEnvInt("CCXT_TIMEOUT_MS");
+    const defaultType = normalizeOptionalString(buildOptions.defaultType) ?? normalizeOptionalString(process.env.CCXT_DEFAULT_TYPE);
+    const defaultSubType = normalizeOptionalString(buildOptions.defaultSubType) ?? normalizeOptionalString(process.env.CCXT_DEFAULT_SUB_TYPE);
+    const settle = normalizeOptionalString(buildOptions.settle) ?? normalizeOptionalString(process.env.CCXT_DEFAULT_SETTLE);
+    const defaultMarginMode = normalizeOptionalString(buildOptions.defaultMarginMode) ??
+        normalizeOptionalString(process.env.CCXT_DEFAULT_MARGIN_MODE);
+    const hedged = buildOptions.hedged ?? envHedged;
+    const mergedOptions = mergeObjects(envOptions, buildOptions.options);
+    if (defaultType) {
+        mergedOptions.defaultType = defaultType;
+    }
+    if (defaultSubType) {
+        mergedOptions.defaultSubType = defaultSubType;
+    }
+    if (settle) {
+        mergedOptions.defaultSettle = settle;
+        mergedOptions.settle = settle;
+    }
+    if (defaultMarginMode) {
+        mergedOptions.defaultMarginMode = defaultMarginMode;
+    }
+    if (hedged !== undefined) {
+        mergedOptions.hedged = hedged;
+    }
+    const mergedHeaders = mergeObjects(envHeaders, buildOptions.headers);
+    const client = new ExchangeCtor({
+        enableRateLimit: buildOptions.enableRateLimit ?? envEnableRateLimit ?? true,
+        timeout: buildOptions.timeoutMs ?? envTimeout ?? 15_000,
+        verbose: buildOptions.verbose ?? envVerbose ?? false,
+        apiKey: process.env.CCXT_API_KEY,
+        secret: process.env.CCXT_API_SECRET,
+        password: process.env.CCXT_PASSWORD,
+        uid: process.env.CCXT_UID,
+        token: process.env.CCXT_TOKEN,
+        privateKey: process.env.CCXT_PRIVATE_KEY,
+        walletAddress: process.env.CCXT_WALLET_ADDRESS,
+        headers: isEmptyObject(mergedHeaders) ? undefined : mergedHeaders,
+        options: mergedOptions,
+    });
+    if (buildOptions.sandbox && typeof client.setSandboxMode === "function") {
+        client.setSandboxMode(true);
+    }
+    return client;
+}
+async function createCcxtClient(exchangeId, buildOptions = {}) {
+    const client = buildCcxtClient(exchangeId, buildOptions);
+    if (buildOptions.loadMarkets) {
+        await callMethod(client, "loadMarkets", []);
+    }
+    return client;
+}
+function buildPmxtClient(exchange, options) {
+    const constructors = pmxt;
+    const normalized = exchange.toLowerCase();
+    const ctorName = PMXT_EXCHANGES[normalized];
+    if (!ctorName) {
+        throw new Error(`Unknown pmxt exchange '${exchange}'. Supported: ${Object.keys(PMXT_EXCHANGES).join(", ")}`);
+    }
+    const ExchangeCtor = constructors[ctorName];
+    if (!ExchangeCtor) {
+        throw new Error(`pmxt constructor '${ctorName}' is unavailable in this pmxtjs version`);
+    }
+    const signatureType = process.env.PMXT_SIGNATURE_TYPE
+        ? Number.parseInt(process.env.PMXT_SIGNATURE_TYPE, 10)
+        : undefined;
+    return new ExchangeCtor({
+        apiKey: process.env.PMXT_API_KEY,
+        privateKey: process.env.PMXT_PRIVATE_KEY,
+        proxyAddress: process.env.PMXT_PROXY_ADDRESS,
+        signatureType: Number.isFinite(signatureType) ? signatureType : undefined,
+        baseUrl: options.baseUrl,
+        autoStartServer: options.autoStartServer,
+    });
+}
+function listCallableMethods(instance) {
+    const methods = new Set();
+    let proto = instance;
+    while (proto && proto !== Object.prototype) {
+        for (const name of Object.getOwnPropertyNames(proto)) {
+            if (name === "constructor" || name.startsWith("_"))
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+            if (descriptor && typeof descriptor.value === "function") {
+                methods.add(name);
+            }
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return [...methods].sort((a, b) => a.localeCompare(b));
+}
+async function callMethod(instance, method, args) {
+    const fn = instance[method];
+    if (typeof fn !== "function") {
+        const sample = listCallableMethods(instance).slice(0, 40).join(", ");
+        throw new Error(`Method '${method}' is not available. Example methods: ${sample}`);
+    }
+    return await fn.apply(instance, args);
+}
+async function closeIfNeeded(instance) {
+    if (!instance?.close)
+        return;
+    await Promise.resolve(instance.close()).catch(() => undefined);
+}
+function addCcxtSharedOptions(command, defaults) {
+    const configured = command
+        .option("--sandbox", "Enable ccxt sandbox mode (if exchange supports it)", false)
+        .option("--default-type <type>", "CCXT defaultType (swap|future|margin|spot|option)")
+        .option("--default-sub-type <type>", "CCXT defaultSubType (linear|inverse)")
+        .option("--settle <code>", "CCXT default settlement asset (e.g. USDT)")
+        .option("--default-margin-mode <mode>", "CCXT default margin mode (cross|isolated)")
+        .option("--hedged", "Set CCXT hedged option true")
+        .option("--headers <json>", "Extra CCXT headers JSON object")
+        .option("--options <json>", "Extra CCXT options JSON object")
+        .option("--timeout-ms <ms>", "Override CCXT timeout in milliseconds")
+        .option("--verbose", "Enable CCXT verbose mode")
+        .option("--disable-rate-limit", "Disable CCXT rate limiter");
+    if (defaults.loadMarkets) {
+        configured.option("--no-load-markets", "Skip loadMarkets before executing the operation");
+    }
+    else {
+        configured.option("--load-markets", "Call loadMarkets before executing the method", false);
+    }
+    return configured;
+}
+function resolveCcxtBuildOptions(opts, defaults) {
+    const timeoutMs = parseOptionalInteger(opts.timeoutMs, "--timeout-ms");
+    const headers = opts.headers ? parseJsonObject(opts.headers, "--headers") : undefined;
+    const options = opts.options ? parseJsonObject(opts.options, "--options") : undefined;
+    return {
+        sandbox: opts.sandbox ?? false,
+        loadMarkets: opts.loadMarkets ?? defaults.loadMarkets,
+        defaultType: normalizeOptionalString(opts.defaultType),
+        defaultSubType: normalizeOptionalString(opts.defaultSubType),
+        settle: normalizeOptionalString(opts.settle),
+        defaultMarginMode: normalizeOptionalString(opts.defaultMarginMode),
+        hedged: opts.hedged ? true : undefined,
+        headers,
+        options,
+        timeoutMs,
+        verbose: opts.verbose ? true : undefined,
+        enableRateLimit: opts.disableRateLimit ? false : undefined,
+    };
+}
+function resolveCcxtFuturesOperationOptions(opts) {
+    const symbols = opts.symbols ? parseJsonStringArray(opts.symbols, "--symbols") : undefined;
+    return {
+        symbol: normalizeOptionalString(opts.symbol),
+        symbols,
+        id: normalizeOptionalString(opts.id),
+        side: normalizeOptionalString(opts.side),
+        orderType: normalizeOptionalString(opts.orderType),
+        amount: parseOptionalPositiveNumber(opts.amount, "--amount"),
+        price: parseOptionalPositiveNumber(opts.price, "--price"),
+        since: parseOptionalInteger(opts.since, "--since"),
+        limit: parseOptionalInteger(opts.limit, "--limit"),
+        leverage: parseOptionalPositiveNumber(opts.leverage, "--leverage"),
+        marginMode: normalizeOptionalString(opts.marginMode),
+        positionMode: normalizeOptionalString(opts.positionMode),
+        code: normalizeOptionalString(opts.code),
+        from: normalizeOptionalString(opts.from),
+        to: normalizeOptionalString(opts.to),
+        params: parseJsonObject(opts.params, "--params"),
+        rawMethod: normalizeOptionalString(opts.rawMethod),
+        rawArgs: parseJsonArray(opts.args),
+    };
+}
+function buildCcxtCapabilitiesSnapshot(instance, exchangeId) {
+    const methods = listCallableMethods(instance);
+    const futuresMethods = listFuturesMethods(instance);
+    const has = asRecord(instance.has) ?? {};
+    const requiredCredentials = asRecord(instance.requiredCredentials) ?? {};
+    const urls = asRecord(instance.urls) ?? {};
+    const venue = inferVenueType(exchangeId);
+    const operationSupport = buildFuturesOperationSupport(instance);
+    const derivativeSupport = deriveDerivativeSupport(has);
+    const basic = {
+        provider: "ccxt",
+        exchangeId,
+        exchangeName: typeof instance.name === "string" ? instance.name : exchangeId,
+        venue,
+        authModel: inferAuthModel(requiredCredentials),
+        rateLimit: typeof instance.rateLimit === "number" ? instance.rateLimit : null,
+        timeoutMs: typeof instance.timeout === "number" ? instance.timeout : null,
+        version: typeof instance.version === "string" ? instance.version : null,
+        countries: Array.isArray(instance.countries) ? instance.countries : [],
+        urls,
+        derivatives: {
+            support: derivativeSupport,
+            futuresOperationSupport: operationSupport,
+        },
+        stats: {
+            methodCount: methods.length,
+            futuresMethodCount: futuresMethods.length,
+            marketStats: buildMarketStats(instance),
+            currencyStats: buildCurrencyStats(instance),
+        },
+    };
+    return {
+        ...basic,
+        has,
+        features: instance.features ?? null,
+        requiredCredentials,
+        timeframes: asRecord(instance.timeframes) ?? {},
+        options: asRecord(instance.options) ?? {},
+        methods,
+        futuresMethods,
+    };
+}
+async function discoverCcxtExchanges(opts) {
+    const includeAll = opts.all ?? false;
+    const includeMethodCounts = opts.withMethodCounts ?? false;
+    const limit = parseOptionalInteger(opts.limit, "--limit");
+    const ids = listCcxtExchangeIds();
+    const exchanges = [];
+    const errors = [];
+    for (const id of ids) {
+        let client = null;
+        try {
+            client = buildCcxtClient(id, {
+                enableRateLimit: false,
+                timeoutMs: 5_000,
+            });
+            const methods = listCallableMethods(client);
+            const futuresMethods = listFuturesMethods(client);
+            const has = asRecord(client.has) ?? {};
+            const derivativeSupport = deriveDerivativeSupport(has);
+            const hasDerivatives = derivativeSupport.perpsOrFutures === true;
+            if (!includeAll && !hasDerivatives) {
+                continue;
+            }
+            const requiredCredentials = asRecord(client.requiredCredentials) ?? {};
+            const row = {
+                id,
+                name: typeof client.name === "string" ? client.name : id,
+                venue: inferVenueType(id),
+                authModel: inferAuthModel(requiredCredentials),
+                derivatives: derivativeSupport,
+            };
+            if (includeMethodCounts) {
+                row.methodCounts = {
+                    all: methods.length,
+                    futures: futuresMethods.length,
+                };
+            }
+            exchanges.push(row);
+            if (limit !== undefined && exchanges.length >= limit) {
+                break;
+            }
+        }
+        catch (err) {
+            errors.push({
+                id,
+                error: toErrorMessage(err),
+            });
+        }
+        finally {
+            await closeIfNeeded(client);
+        }
+    }
+    return {
+        provider: "ccxt",
+        scanned: ids.length,
+        returned: exchanges.length,
+        filters: {
+            includeAll,
+            includeMethodCounts,
+            limit: limit ?? null,
+        },
+        exchanges,
+        errors: errors.slice(0, 50),
+        errorCount: errors.length,
+    };
+}
+export function registerDataCommands(program) {
+    const data = program
+        .command("data")
+        .description("Arbitrary connector-backed data pulls (ccxt + pmxt)");
+    addCcxtSharedOptions(data
+        .command("ccxt <exchangeId> <method>")
+        .description("Call a raw ccxt method on an exchange")
+        .option("--args <json>", "JSON array of positional args", "[]"), { loadMarkets: false }).action(async function (exchangeId, method) {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        let client = null;
+        try {
+            const args = parseJsonArray(opts.args);
+            const buildOptions = resolveCcxtBuildOptions(opts, { loadMarkets: false });
+            client = await createCcxtClient(exchangeId, buildOptions);
+            const result = await callMethod(client, method, args);
+            output(result, outputOpts);
+        }
+        catch (err) {
+            outputError(toErrorMessage(err));
+            process.exitCode = 1;
+        }
+        finally {
+            await closeIfNeeded(client);
+        }
+    });
+    addCcxtSharedOptions(data
+        .command("ccxt-methods <exchangeId>")
+        .description("List callable methods exposed by a ccxt exchange client")
+        .option("--futures", "Filter for futures/perps-relevant methods", false), { loadMarkets: false }).action(async function (exchangeId) {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        let client = null;
+        try {
+            const buildOptions = resolveCcxtBuildOptions(opts, { loadMarkets: false });
+            client = await createCcxtClient(exchangeId, buildOptions);
+            const methods = opts.futures ? listFuturesMethods(client) : listCallableMethods(client);
+            output({
+                provider: "ccxt",
+                exchangeId: exchangeId.toLowerCase(),
+                futuresOnly: opts.futures ?? false,
+                methods,
+            }, outputOpts);
+        }
+        catch (err) {
+            outputError(toErrorMessage(err));
+            process.exitCode = 1;
+        }
+        finally {
+            await closeIfNeeded(client);
+        }
+    });
+    data
+        .command("ccxt-exchanges")
+        .description("Discover CCXT exchange coverage for futures/perps and likely venue model")
+        .option("--all", "Include exchanges without derivative support signals", false)
+        .option("--with-method-counts", "Include total/futures method counts", false)
+        .option("--limit <n>", "Limit output rows")
+        .action(async function () {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        try {
+            const result = await discoverCcxtExchanges(opts);
+            output(result, outputOpts);
+        }
+        catch (err) {
+            outputError(toErrorMessage(err));
+            process.exitCode = 1;
+        }
+    });
+    addCcxtSharedOptions(data
+        .command("ccxt-capabilities <exchangeId>")
+        .description("Show deep capability map for one CCXT exchange (methods, features, derivatives support)")
+        .option("--lite", "Return reduced summary only", false)
+        .option("--futures", "Default CCXT market type to swap for this probe", false), { loadMarkets: true }).action(async function (exchangeId) {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        let client = null;
+        const warnings = [];
+        try {
+            const buildOptions = resolveCcxtBuildOptions({
+                ...opts,
+                defaultType: opts.defaultType ?? (opts.futures ? "swap" : undefined),
+            }, { loadMarkets: true });
+            try {
+                client = await createCcxtClient(exchangeId, buildOptions);
+            }
+            catch (err) {
+                if (!buildOptions.loadMarkets) {
+                    throw err;
+                }
+                warnings.push(`loadMarkets failed; continuing without market metadata: ${toErrorMessage(err)}`);
+                client = await createCcxtClient(exchangeId, {
+                    ...buildOptions,
+                    loadMarkets: false,
+                });
+            }
+            const snapshot = buildCcxtCapabilitiesSnapshot(client, exchangeId.toLowerCase());
+            if (opts.lite) {
+                output({
+                    provider: "ccxt",
+                    exchangeId: snapshot.exchangeId,
+                    exchangeName: snapshot.exchangeName,
+                    venue: snapshot.venue,
+                    authModel: snapshot.authModel,
+                    derivatives: snapshot.derivatives.support,
+                    stats: snapshot.stats,
+                    warnings,
+                }, outputOpts);
+                return;
+            }
+            output({
+                ...snapshot,
+                warnings,
+            }, outputOpts);
+        }
+        catch (err) {
+            outputError(toErrorMessage(err));
+            process.exitCode = 1;
+        }
+        finally {
+            await closeIfNeeded(client);
+        }
+    });
+    addCcxtSharedOptions(data
+        .command("ccxt-futures <exchangeId> <operation>")
+        .description("High-level futures/perps workflow operations via ccxt")
+        .option("--symbol <symbol>", "Market symbol (for example BTC/USDT:USDT)")
+        .option("--symbols <json>", "JSON array of symbols")
+        .option("--id <id>", "Order or transfer ID")
+        .option("--side <side>", "Order side (buy|sell)")
+        .option("--order-type <type>", "Order type (market|limit|stop|take_profit)")
+        .option("--amount <amount>", "Order, transfer, or margin amount")
+        .option("--price <price>", "Order price")
+        .option("--since <ms>", "Start timestamp in ms for pagination")
+        .option("--limit <count>", "Pagination limit")
+        .option("--leverage <x>", "Leverage value")
+        .option("--margin-mode <mode>", "Margin mode (cross|isolated)")
+        .option("--position-mode <mode>", "Position mode (hedged|oneway)")
+        .option("--code <asset>", "Transfer/borrow asset code (for example USDT)")
+        .option("--from <account>", "Transfer source account")
+        .option("--to <account>", "Transfer destination account")
+        .option("--params <json>", "JSON object appended as ccxt params", "{}")
+        .option("--raw-method <method>", "Raw method for operation=raw")
+        .option("--args <json>", "Raw args JSON array for operation=raw", "[]"), { loadMarkets: true }).action(async function (exchangeId, operation) {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        let client = null;
+        try {
+            const buildOptions = resolveCcxtBuildOptions({
+                ...opts,
+                defaultType: opts.defaultType ?? "swap",
+            }, { loadMarkets: true });
+            client = await createCcxtClient(exchangeId, buildOptions);
+            const operationOptions = resolveCcxtFuturesOperationOptions(opts);
+            const normalizedOperation = resolveOperation(operation);
+            const result = await executeCcxtFuturesOperation(client, normalizedOperation, operationOptions);
+            output({
+                provider: "ccxt",
+                scope: "futures",
+                exchangeId: exchangeId.toLowerCase(),
+                operation: normalizedOperation,
+                result,
+            }, outputOpts);
+        }
+        catch (err) {
+            outputError(toErrorMessage(err));
+            process.exitCode = 1;
+        }
+        finally {
+            await closeIfNeeded(client);
+        }
+    });
+    data
+        .command("pmxt <exchange> <method>")
+        .description("Call a raw pmxt method on an exchange (polymarket|kalshi|limitless)")
+        .option("--args <json>", "JSON array of positional args", "[]")
+        .option("--base-url <url>", "Override PMXT server URL (default: PMXT_BASE_URL or localhost)")
+        .option("--no-auto-start", "Disable PMXT sidecar auto-start")
+        .action(async function (exchange, method) {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        let client = null;
+        try {
+            const args = parseJsonArray(opts.args);
+            client = buildPmxtClient(exchange, {
+                baseUrl: opts.baseUrl ?? process.env.PMXT_BASE_URL,
+                autoStartServer: opts.autoStart,
+            });
+            const result = await callMethod(client, method, args);
+            output(result, outputOpts);
+        }
+        catch (err) {
+            outputError(toErrorMessage(err));
+            process.exitCode = 1;
+        }
+        finally {
+            await closeIfNeeded(client);
+        }
+    });
+    data
+        .command("pmxt-methods <exchange>")
+        .description("List callable methods exposed by a pmxt exchange client")
+        .option("--base-url <url>", "Override PMXT server URL (default: PMXT_BASE_URL or localhost)")
+        .action(async function (exchange) {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        let client = null;
+        try {
+            client = buildPmxtClient(exchange, {
+                baseUrl: opts.baseUrl ?? process.env.PMXT_BASE_URL,
+                autoStartServer: false,
+            });
+            output({
+                provider: "pmxt",
+                exchange: exchange.toLowerCase(),
+                methods: listCallableMethods(client),
+            }, outputOpts);
+        }
+        catch (err) {
+            outputError(toErrorMessage(err));
+            process.exitCode = 1;
+        }
+        finally {
+            await closeIfNeeded(client);
+        }
+    });
+}