@raintree-technology/perps 0.1.0

package/dist/lib/risk/policy-middleware.js

@@ -0,0 +1,267 @@
+import { eventBus } from "../events/bus.js";
+import { readOperatorState, updateOperatorHeartbeat, } from "../operator-state.js";
+import { createLogger } from "../logger.js";
+import { RiskManager } from "./manager.js";
+import { getRulesForContext } from "./rules-store.js";
+import { logRiskEvaluation } from "./evaluation-log.js";
+const log = createLogger("risk:policy");
+export class RiskPolicyMiddleware {
+    config;
+    exchangeId;
+    manager;
+    constructor(config, exchangeId) {
+        this.config = config;
+        this.exchangeId = exchangeId.toLowerCase();
+        const state = readOperatorState();
+        this.manager = new RiskManager({
+            positionSizer: {
+                maxPositionSizeUsd: config.risk.maxPositionSizeUsd,
+                defaultLeverage: config.risk.defaultLeverage,
+            },
+            limits: {
+                maxPositionSizeUsd: config.risk.maxPositionSizeUsd,
+                maxTotalExposureUsd: config.risk.maxTotalExposureUsd,
+                maxLeverage: config.risk.maxLeverage,
+                minSignalConfidence: config.risk.minSignalConfidence,
+            },
+            maxDrawdownPct: config.risk.maxDrawdownPct,
+            initialDrawdownState: {
+                peakEquity: state.heartbeat?.peakEquity ?? 0,
+                halted: state.heartbeat?.halted ?? false,
+            },
+        });
+    }
+    async evaluateUsdSignal(adapter, signal, proposedSizeUsd, traceId) {
+        const state = readOperatorState();
+        if (state.killSwitch.enabled) {
+            this.recordHeartbeat({
+                equity: state.heartbeat?.equity ?? 0,
+                exposureUsd: state.heartbeat?.exposureUsd ?? 0,
+                drawdownPct: state.heartbeat?.drawdownPct ?? 0,
+                peakEquity: state.heartbeat?.peakEquity ?? 0,
+                halted: true,
+                haltReason: state.killSwitch.reason ?? "Manual kill switch enabled",
+            });
+            return {
+                allowed: false,
+                sizeUsd: 0,
+                reason: state.killSwitch.reason ?? "Manual kill switch enabled",
+            };
+        }
+        const metrics = await this.loadAccountMetrics(adapter);
+        const evaluation = this.manager.evaluate(signal, metrics.equity, metrics.exposureUsd, proposedSizeUsd);
+        const halted = evaluation.halted || state.killSwitch.enabled;
+        this.recordHeartbeat({
+            equity: metrics.equity,
+            exposureUsd: metrics.exposureUsd,
+            drawdownPct: evaluation.drawdownPct,
+            peakEquity: evaluation.peakEquity,
+            halted,
+            haltReason: evaluation.reason,
+            market: signal.market,
+        });
+        // --- Data-driven rules overlay ---
+        const rules = getRulesForContext(signal.market, this.exchangeId);
+        const rulesEvaluated = rules.map((r) => r.name);
+        const rulesFired = [];
+        let finalSizeUsd = evaluation.sizeUsd;
+        let finalAllowed = evaluation.allowed;
+        let finalReason = evaluation.reason;
+        for (const rule of rules) {
+            if (rule.type === "max_position_size" && finalSizeUsd > rule.value) {
+                finalSizeUsd = rule.value;
+                rulesFired.push(rule.name);
+            }
+            if (rule.type === "max_total_exposure" && metrics.exposureUsd + finalSizeUsd > rule.value) {
+                finalSizeUsd = Math.max(0, rule.value - metrics.exposureUsd);
+                if (finalSizeUsd === 0) {
+                    finalAllowed = false;
+                    finalReason = `Blocked by rule: ${rule.name}`;
+                }
+                rulesFired.push(rule.name);
+            }
+            if (rule.type === "max_leverage") {
+                const projectedLeverage = (metrics.exposureUsd + finalSizeUsd) / metrics.equity;
+                if (projectedLeverage > rule.value) {
+                    finalSizeUsd = Math.max(0, rule.value * metrics.equity - metrics.exposureUsd);
+                    if (finalSizeUsd === 0) {
+                        finalAllowed = false;
+                        finalReason = `Blocked by rule: ${rule.name}`;
+                    }
+                    rulesFired.push(rule.name);
+                }
+            }
+            if (rule.type === "max_drawdown" && evaluation.drawdownPct > rule.value) {
+                finalAllowed = false;
+                finalReason = `Blocked by rule: ${rule.name} (drawdown ${evaluation.drawdownPct.toFixed(1)}% > ${rule.value}%)`;
+                rulesFired.push(rule.name);
+            }
+            if (rule.type === "min_confidence" && (signal.confidence ?? 0) < rule.value) {
+                finalAllowed = false;
+                finalReason = `Blocked by rule: ${rule.name} (confidence ${signal.confidence} < ${rule.value})`;
+                rulesFired.push(rule.name);
+            }
+        }
+        // --- Log the evaluation ---
+        try {
+            logRiskEvaluation({
+                traceId,
+                exchange: this.exchangeId,
+                market: signal.market,
+                side: signal.side,
+                requestedSizeUsd: proposedSizeUsd,
+                equity: metrics.equity,
+                exposureUsd: metrics.exposureUsd,
+                confidence: signal.confidence,
+                allowed: finalAllowed,
+                adjustedSizeUsd: finalSizeUsd,
+                drawdownPct: evaluation.drawdownPct,
+                rulesEvaluated,
+                rulesFired,
+                reason: finalReason ?? null,
+            });
+        }
+        catch {
+            // Don't let logging failure block trading
+        }
+        if (!finalAllowed) {
+            eventBus.emit("risk.evaluation.denied", {
+                exchange: this.exchangeId,
+                market: signal.market,
+                reason: finalReason ?? "unknown",
+                traceId,
+                timestamp: Date.now(),
+            });
+            log.warn("Signal blocked by risk policy", {
+                exchange: this.exchangeId,
+                market: signal.market,
+                reason: finalReason,
+            });
+        }
+        return {
+            allowed: finalAllowed,
+            sizeUsd: finalSizeUsd,
+            reason: finalReason,
+        };
+    }
+    async evaluateOrder(adapter, input, traceId) {
+        const referencePriceUsd = await this.resolveReferencePrice(adapter, input.market, input.referencePriceUsd);
+        const requestedSizeUsd = input.requestedSizeBase * referencePriceUsd;
+        const confidence = clampConfidence(input.confidence ?? 1);
+        const signal = {
+            market: input.market,
+            side: input.side,
+            confidence,
+            reason: input.reason ?? "cli-order",
+            timestamp: Date.now(),
+        };
+        const result = await this.evaluateUsdSignal(adapter, signal, requestedSizeUsd, traceId);
+        const adjustedSizeUsd = Math.min(result.sizeUsd, requestedSizeUsd);
+        const adjustedSizeBase = adjustedSizeUsd / referencePriceUsd;
+        return {
+            allowed: result.allowed,
+            adjustedSizeBase: Number.isFinite(adjustedSizeBase) ? adjustedSizeBase : 0,
+            adjustedSizeUsd,
+            referencePriceUsd,
+            reason: result.reason,
+        };
+    }
+    async resolveReferencePrice(adapter, market, explicitPrice) {
+        if (explicitPrice !== undefined && explicitPrice > 0) {
+            return explicitPrice;
+        }
+        try {
+            const book = await adapter.getOrderBook(market, 1);
+            const bid = parseFloat(book.bids[0]?.price ?? "");
+            const ask = parseFloat(book.asks[0]?.price ?? "");
+            if (Number.isFinite(bid) && Number.isFinite(ask) && bid > 0 && ask > 0) {
+                return (bid + ask) / 2;
+            }
+        }
+        catch {
+            // fall through to ticker fallback
+        }
+        const ticker = await adapter.getTicker(market);
+        const mark = parseFloat(ticker.markPrice);
+        const last = parseFloat(ticker.lastPrice);
+        const resolved = Number.isFinite(mark) && mark > 0 ? mark : last;
+        if (!Number.isFinite(resolved) || resolved <= 0) {
+            throw new Error(`Unable to resolve reference price for ${market}`);
+        }
+        return resolved;
+    }
+    async loadAccountMetrics(adapter) {
+        const state = readOperatorState();
+        let equity = 0;
+        let exposureUsd = 0;
+        try {
+            const balances = await adapter.getBalances();
+            equity = resolveEquityFromBalances(balances);
+        }
+        catch {
+            // Some adapters might not support balances yet.
+        }
+        try {
+            const positions = await adapter.getPositions();
+            exposureUsd = positions.reduce((sum, pos) => {
+                const size = Math.abs(parseFloat(pos.size));
+                const mark = parseFloat(pos.markPrice);
+                if (!Number.isFinite(size) || !Number.isFinite(mark))
+                    return sum;
+                return sum + size * mark;
+            }, 0);
+        }
+        catch {
+            // Some adapters might not support positions yet.
+        }
+        if (!Number.isFinite(equity) || equity <= 0) {
+            equity = state.heartbeat?.equity ?? 0;
+        }
+        if (!Number.isFinite(equity) || equity <= 0) {
+            throw new Error("Risk policy requires account equity. Ensure authenticated account endpoints are available.");
+        }
+        if (!Number.isFinite(exposureUsd) || exposureUsd < 0) {
+            exposureUsd = state.heartbeat?.exposureUsd ?? 0;
+        }
+        return { equity, exposureUsd };
+    }
+    recordHeartbeat(metrics) {
+        const snapshot = {
+            exchange: metrics.exchange ?? this.exchangeId,
+            market: metrics.market,
+            equity: metrics.equity,
+            exposureUsd: metrics.exposureUsd,
+            drawdownPct: metrics.drawdownPct,
+            peakEquity: metrics.peakEquity,
+            halted: metrics.halted,
+            haltReason: metrics.haltReason,
+            updatedAt: Date.now(),
+        };
+        updateOperatorHeartbeat(snapshot);
+        log.info("heartbeat", snapshot);
+    }
+}
+function clampConfidence(confidence) {
+    if (!Number.isFinite(confidence))
+        return 0;
+    if (confidence < 0)
+        return 0;
+    if (confidence > 1)
+        return 1;
+    return confidence;
+}
+function resolveEquityFromBalances(balances) {
+    if (balances.length === 0) {
+        return 0;
+    }
+    const preferred = balances.find((b) => b.asset.toUpperCase() === "USD");
+    const candidate = preferred ?? balances[0];
+    const equity = parseFloat(candidate.total);
+    if (!Number.isFinite(equity) || equity <= 0) {
+        return balances.reduce((sum, bal) => {
+            const total = parseFloat(bal.total);
+            return Number.isFinite(total) ? sum + total : sum;
+        }, 0);
+    }
+    return equity;
+}

package/dist/lib/risk/position-sizer.d.ts

@@ -0,0 +1,9 @@
+export interface PositionSizerConfig {
+    maxPositionSizeUsd: number;
+    defaultLeverage: number;
+}
+export declare class PositionSizer {
+    private readonly config;
+    constructor(config: PositionSizerConfig);
+    calculate(equity: number, confidence: number, existingExposureUsd: number): number;
+}

package/dist/lib/risk/position-sizer.js

@@ -0,0 +1,14 @@
+const MAX_POSITION_FRACTION_OF_EQUITY = 0.25;
+export class PositionSizer {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    calculate(equity, confidence, existingExposureUsd) {
+        const maxSize = Math.min(this.config.maxPositionSizeUsd, equity * MAX_POSITION_FRACTION_OF_EQUITY);
+        const size = maxSize * confidence;
+        const maxTotalExposure = equity * this.config.defaultLeverage;
+        const available = maxTotalExposure - existingExposureUsd;
+        return Math.max(0, Math.min(size, available));
+    }
+}

package/dist/lib/risk/rules-store.d.ts

@@ -0,0 +1,16 @@
+export type RiskRuleType = "max_position_size" | "max_total_exposure" | "max_leverage" | "max_drawdown" | "min_confidence" | "cooldown_after_loss" | "rate_limit";
+export type RiskRuleScope = "global" | "exchange" | "market" | "strategy";
+export interface RiskRule {
+    id: number;
+    name: string;
+    type: RiskRuleType;
+    scope: RiskRuleScope;
+    scopeValue: string | null;
+    value: number;
+    enabled: boolean;
+    createdAt: number;
+}
+export declare function addRiskRule(rule: Omit<RiskRule, "id" | "createdAt">): number;
+export declare function listRiskRules(): RiskRule[];
+export declare function getRulesForContext(market?: string, exchange?: string, strategy?: string): RiskRule[];
+export declare function removeRiskRule(id: number): boolean;

package/dist/lib/risk/rules-store.js

@@ -0,0 +1,47 @@
+import { getDb } from "../db/index.js";
+function rowToRule(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        scope: row.scope,
+        scopeValue: row.scope_value,
+        value: row.value,
+        enabled: row.enabled === 1,
+        createdAt: row.created_at,
+    };
+}
+export function addRiskRule(rule) {
+    const db = getDb();
+    const stmt = db.prepare(`INSERT INTO risk_rules (name, type, scope, scope_value, value, enabled)
+     VALUES (?, ?, ?, ?, ?, ?)`);
+    const result = stmt.run(rule.name, rule.type, rule.scope, rule.scopeValue, rule.value, rule.enabled ? 1 : 0);
+    return Number(result.lastInsertRowid);
+}
+export function listRiskRules() {
+    const db = getDb();
+    const rows = db
+        .prepare("SELECT * FROM risk_rules ORDER BY created_at DESC")
+        .all();
+    return rows.map(rowToRule);
+}
+export function getRulesForContext(market, exchange, strategy) {
+    const db = getDb();
+    const rows = db
+        .prepare(`SELECT * FROM risk_rules
+       WHERE enabled = 1
+         AND (
+           scope = 'global'
+           OR (scope = 'market' AND scope_value = ?)
+           OR (scope = 'exchange' AND scope_value = ?)
+           OR (scope = 'strategy' AND scope_value = ?)
+         )
+       ORDER BY created_at DESC`)
+        .all(market ?? null, exchange ?? null, strategy ?? null);
+    return rows.map(rowToRule);
+}
+export function removeRiskRule(id) {
+    const db = getDb();
+    const result = db.prepare("DELETE FROM risk_rules WHERE id = ?").run(id);
+    return result.changes > 0;
+}

package/dist/lib/schema.d.ts

@@ -0,0 +1,254 @@
+import { z } from "zod";
+export declare const envSchema: z.ZodEffects<z.ZodObject<{
+    HYPERLIQUID_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
+    HYPERLIQUID_WALLET_ADDRESS: z.ZodOptional<z.ZodString>;
+    HYPERLIQUID_NETWORK: z.ZodOptional<z.ZodEnum<["testnet", "mainnet"]>>;
+    DECIBEL_API_WALLET_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
+    DECIBEL_API_WALLET_ADDRESS: z.ZodOptional<z.ZodString>;
+    DECIBEL_API_BEARER_TOKEN: z.ZodOptional<z.ZodString>;
+    DECIBEL_SUBACCOUNT_ADDRESS: z.ZodOptional<z.ZodString>;
+    DECIBEL_PACKAGE_ADDRESS: z.ZodOptional<z.ZodString>;
+    DECIBEL_REST_URL: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    DECIBEL_WS_URL: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    DECIBEL_FULLNODE_URL: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    DECIBEL_NETWORK: z.ZodOptional<z.ZodEnum<["testnet", "mainnet"]>>;
+    AEVO_API_KEY: z.ZodOptional<z.ZodString>;
+    AEVO_API_SECRET: z.ZodOptional<z.ZodString>;
+    AEVO_SIGNING_KEY: z.ZodOptional<z.ZodString>;
+    AEVO_ACCOUNT_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
+    AEVO_REST_URL: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    AEVO_NETWORK: z.ZodOptional<z.ZodEnum<["testnet", "mainnet"]>>;
+    ORDERLY_BROKER_ID: z.ZodOptional<z.ZodString>;
+    ORDERLY_CHAIN_ID: z.ZodOptional<z.ZodString>;
+    ORDERLY_ACCOUNT_ID: z.ZodOptional<z.ZodString>;
+    ORDERLY_KEY: z.ZodOptional<z.ZodString>;
+    ORDERLY_SECRET: z.ZodOptional<z.ZodString>;
+    ORDERLY_TRADING_KEY: z.ZodOptional<z.ZodString>;
+    ORDERLY_TRADING_SECRET: z.ZodOptional<z.ZodString>;
+    ORDERLY_REST_URL: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    ORDERLY_NETWORK: z.ZodOptional<z.ZodEnum<["testnet", "mainnet"]>>;
+    PARADEX_API_BEARER_TOKEN: z.ZodOptional<z.ZodString>;
+    PARADEX_ACCOUNT_ADDRESS: z.ZodOptional<z.ZodString>;
+    PARADEX_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
+    PARADEX_ETHEREUM_ACCOUNT: z.ZodOptional<z.ZodString>;
+    PARADEX_CHAIN_ID: z.ZodOptional<z.ZodString>;
+    PARADEX_REST_URL: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    PARADEX_NETWORK: z.ZodOptional<z.ZodEnum<["testnet", "mainnet"]>>;
+    RISK_MAX_POSITION_SIZE_USD: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    RISK_MAX_TOTAL_EXPOSURE_USD: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    RISK_MAX_LEVERAGE: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    RISK_MIN_SIGNAL_CONFIDENCE: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    RISK_MAX_DRAWDOWN_PCT: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    RISK_DEFAULT_LEVERAGE: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    EXECUTION_STOP_LOSS_PCT: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    EXECUTION_TAKE_PROFIT_PCT: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    EXECUTION_SPREAD_OFFSET_PCT: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    OPERATOR_HEARTBEAT_INTERVAL_MS: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    PERPS_ALLOW_UNTRUSTED_ENDPOINTS: z.ZodOptional<z.ZodEnum<["0", "1", "true", "false"]>>;
+    PERPS_BLOCKED_EXCHANGES: z.ZodOptional<z.ZodString>;
+    PERPS_BLOCKED_MARKETS: z.ZodOptional<z.ZodString>;
+    PERPS_BLOCKED_MARKET_PATTERNS: z.ZodOptional<z.ZodString>;
+    PERPS_REPUTATION_BLOCKLIST_FILE: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    RISK_MAX_POSITION_SIZE_USD: number;
+    RISK_MAX_TOTAL_EXPOSURE_USD: number;
+    RISK_MAX_LEVERAGE: number;
+    RISK_MIN_SIGNAL_CONFIDENCE: number;
+    RISK_MAX_DRAWDOWN_PCT: number;
+    RISK_DEFAULT_LEVERAGE: number;
+    EXECUTION_STOP_LOSS_PCT: number;
+    EXECUTION_TAKE_PROFIT_PCT: number;
+    EXECUTION_SPREAD_OFFSET_PCT: number;
+    OPERATOR_HEARTBEAT_INTERVAL_MS: number;
+    DECIBEL_REST_URL?: string | undefined;
+    DECIBEL_WS_URL?: string | undefined;
+    DECIBEL_FULLNODE_URL?: string | undefined;
+    AEVO_REST_URL?: string | undefined;
+    ORDERLY_REST_URL?: string | undefined;
+    PARADEX_REST_URL?: string | undefined;
+    HYPERLIQUID_PRIVATE_KEY?: string | undefined;
+    HYPERLIQUID_WALLET_ADDRESS?: string | undefined;
+    HYPERLIQUID_NETWORK?: "testnet" | "mainnet" | undefined;
+    DECIBEL_API_WALLET_PRIVATE_KEY?: string | undefined;
+    DECIBEL_API_WALLET_ADDRESS?: string | undefined;
+    DECIBEL_API_BEARER_TOKEN?: string | undefined;
+    DECIBEL_SUBACCOUNT_ADDRESS?: string | undefined;
+    DECIBEL_PACKAGE_ADDRESS?: string | undefined;
+    DECIBEL_NETWORK?: "testnet" | "mainnet" | undefined;
+    AEVO_API_KEY?: string | undefined;
+    AEVO_API_SECRET?: string | undefined;
+    AEVO_SIGNING_KEY?: string | undefined;
+    AEVO_ACCOUNT_PRIVATE_KEY?: string | undefined;
+    AEVO_NETWORK?: "testnet" | "mainnet" | undefined;
+    ORDERLY_BROKER_ID?: string | undefined;
+    ORDERLY_CHAIN_ID?: string | undefined;
+    ORDERLY_ACCOUNT_ID?: string | undefined;
+    ORDERLY_KEY?: string | undefined;
+    ORDERLY_SECRET?: string | undefined;
+    ORDERLY_TRADING_KEY?: string | undefined;
+    ORDERLY_TRADING_SECRET?: string | undefined;
+    ORDERLY_NETWORK?: "testnet" | "mainnet" | undefined;
+    PARADEX_API_BEARER_TOKEN?: string | undefined;
+    PARADEX_ACCOUNT_ADDRESS?: string | undefined;
+    PARADEX_PRIVATE_KEY?: string | undefined;
+    PARADEX_ETHEREUM_ACCOUNT?: string | undefined;
+    PARADEX_CHAIN_ID?: string | undefined;
+    PARADEX_NETWORK?: "testnet" | "mainnet" | undefined;
+    PERPS_ALLOW_UNTRUSTED_ENDPOINTS?: "0" | "1" | "true" | "false" | undefined;
+    PERPS_BLOCKED_EXCHANGES?: string | undefined;
+    PERPS_BLOCKED_MARKETS?: string | undefined;
+    PERPS_BLOCKED_MARKET_PATTERNS?: string | undefined;
+    PERPS_REPUTATION_BLOCKLIST_FILE?: string | undefined;
+}, {
+    DECIBEL_REST_URL?: string | undefined;
+    DECIBEL_WS_URL?: string | undefined;
+    DECIBEL_FULLNODE_URL?: string | undefined;
+    AEVO_REST_URL?: string | undefined;
+    ORDERLY_REST_URL?: string | undefined;
+    PARADEX_REST_URL?: string | undefined;
+    HYPERLIQUID_PRIVATE_KEY?: string | undefined;
+    HYPERLIQUID_WALLET_ADDRESS?: string | undefined;
+    HYPERLIQUID_NETWORK?: "testnet" | "mainnet" | undefined;
+    DECIBEL_API_WALLET_PRIVATE_KEY?: string | undefined;
+    DECIBEL_API_WALLET_ADDRESS?: string | undefined;
+    DECIBEL_API_BEARER_TOKEN?: string | undefined;
+    DECIBEL_SUBACCOUNT_ADDRESS?: string | undefined;
+    DECIBEL_PACKAGE_ADDRESS?: string | undefined;
+    DECIBEL_NETWORK?: "testnet" | "mainnet" | undefined;
+    AEVO_API_KEY?: string | undefined;
+    AEVO_API_SECRET?: string | undefined;
+    AEVO_SIGNING_KEY?: string | undefined;
+    AEVO_ACCOUNT_PRIVATE_KEY?: string | undefined;
+    AEVO_NETWORK?: "testnet" | "mainnet" | undefined;
+    ORDERLY_BROKER_ID?: string | undefined;
+    ORDERLY_CHAIN_ID?: string | undefined;
+    ORDERLY_ACCOUNT_ID?: string | undefined;
+    ORDERLY_KEY?: string | undefined;
+    ORDERLY_SECRET?: string | undefined;
+    ORDERLY_TRADING_KEY?: string | undefined;
+    ORDERLY_TRADING_SECRET?: string | undefined;
+    ORDERLY_NETWORK?: "testnet" | "mainnet" | undefined;
+    PARADEX_API_BEARER_TOKEN?: string | undefined;
+    PARADEX_ACCOUNT_ADDRESS?: string | undefined;
+    PARADEX_PRIVATE_KEY?: string | undefined;
+    PARADEX_ETHEREUM_ACCOUNT?: string | undefined;
+    PARADEX_CHAIN_ID?: string | undefined;
+    PARADEX_NETWORK?: "testnet" | "mainnet" | undefined;
+    RISK_MAX_POSITION_SIZE_USD?: number | undefined;
+    RISK_MAX_TOTAL_EXPOSURE_USD?: number | undefined;
+    RISK_MAX_LEVERAGE?: number | undefined;
+    RISK_MIN_SIGNAL_CONFIDENCE?: number | undefined;
+    RISK_MAX_DRAWDOWN_PCT?: number | undefined;
+    RISK_DEFAULT_LEVERAGE?: number | undefined;
+    EXECUTION_STOP_LOSS_PCT?: number | undefined;
+    EXECUTION_TAKE_PROFIT_PCT?: number | undefined;
+    EXECUTION_SPREAD_OFFSET_PCT?: number | undefined;
+    OPERATOR_HEARTBEAT_INTERVAL_MS?: number | undefined;
+    PERPS_ALLOW_UNTRUSTED_ENDPOINTS?: "0" | "1" | "true" | "false" | undefined;
+    PERPS_BLOCKED_EXCHANGES?: string | undefined;
+    PERPS_BLOCKED_MARKETS?: string | undefined;
+    PERPS_BLOCKED_MARKET_PATTERNS?: string | undefined;
+    PERPS_REPUTATION_BLOCKLIST_FILE?: string | undefined;
+}>, {
+    RISK_MAX_POSITION_SIZE_USD: number;
+    RISK_MAX_TOTAL_EXPOSURE_USD: number;
+    RISK_MAX_LEVERAGE: number;
+    RISK_MIN_SIGNAL_CONFIDENCE: number;
+    RISK_MAX_DRAWDOWN_PCT: number;
+    RISK_DEFAULT_LEVERAGE: number;
+    EXECUTION_STOP_LOSS_PCT: number;
+    EXECUTION_TAKE_PROFIT_PCT: number;
+    EXECUTION_SPREAD_OFFSET_PCT: number;
+    OPERATOR_HEARTBEAT_INTERVAL_MS: number;
+    DECIBEL_REST_URL?: string | undefined;
+    DECIBEL_WS_URL?: string | undefined;
+    DECIBEL_FULLNODE_URL?: string | undefined;
+    AEVO_REST_URL?: string | undefined;
+    ORDERLY_REST_URL?: string | undefined;
+    PARADEX_REST_URL?: string | undefined;
+    HYPERLIQUID_PRIVATE_KEY?: string | undefined;
+    HYPERLIQUID_WALLET_ADDRESS?: string | undefined;
+    HYPERLIQUID_NETWORK?: "testnet" | "mainnet" | undefined;
+    DECIBEL_API_WALLET_PRIVATE_KEY?: string | undefined;
+    DECIBEL_API_WALLET_ADDRESS?: string | undefined;
+    DECIBEL_API_BEARER_TOKEN?: string | undefined;
+    DECIBEL_SUBACCOUNT_ADDRESS?: string | undefined;
+    DECIBEL_PACKAGE_ADDRESS?: string | undefined;
+    DECIBEL_NETWORK?: "testnet" | "mainnet" | undefined;
+    AEVO_API_KEY?: string | undefined;
+    AEVO_API_SECRET?: string | undefined;
+    AEVO_SIGNING_KEY?: string | undefined;
+    AEVO_ACCOUNT_PRIVATE_KEY?: string | undefined;
+    AEVO_NETWORK?: "testnet" | "mainnet" | undefined;
+    ORDERLY_BROKER_ID?: string | undefined;
+    ORDERLY_CHAIN_ID?: string | undefined;
+    ORDERLY_ACCOUNT_ID?: string | undefined;
+    ORDERLY_KEY?: string | undefined;
+    ORDERLY_SECRET?: string | undefined;
+    ORDERLY_TRADING_KEY?: string | undefined;
+    ORDERLY_TRADING_SECRET?: string | undefined;
+    ORDERLY_NETWORK?: "testnet" | "mainnet" | undefined;
+    PARADEX_API_BEARER_TOKEN?: string | undefined;
+    PARADEX_ACCOUNT_ADDRESS?: string | undefined;
+    PARADEX_PRIVATE_KEY?: string | undefined;
+    PARADEX_ETHEREUM_ACCOUNT?: string | undefined;
+    PARADEX_CHAIN_ID?: string | undefined;
+    PARADEX_NETWORK?: "testnet" | "mainnet" | undefined;
+    PERPS_ALLOW_UNTRUSTED_ENDPOINTS?: "0" | "1" | "true" | "false" | undefined;
+    PERPS_BLOCKED_EXCHANGES?: string | undefined;
+    PERPS_BLOCKED_MARKETS?: string | undefined;
+    PERPS_BLOCKED_MARKET_PATTERNS?: string | undefined;
+    PERPS_REPUTATION_BLOCKLIST_FILE?: string | undefined;
+}, {
+    DECIBEL_REST_URL?: string | undefined;
+    DECIBEL_WS_URL?: string | undefined;
+    DECIBEL_FULLNODE_URL?: string | undefined;
+    AEVO_REST_URL?: string | undefined;
+    ORDERLY_REST_URL?: string | undefined;
+    PARADEX_REST_URL?: string | undefined;
+    HYPERLIQUID_PRIVATE_KEY?: string | undefined;
+    HYPERLIQUID_WALLET_ADDRESS?: string | undefined;
+    HYPERLIQUID_NETWORK?: "testnet" | "mainnet" | undefined;
+    DECIBEL_API_WALLET_PRIVATE_KEY?: string | undefined;
+    DECIBEL_API_WALLET_ADDRESS?: string | undefined;
+    DECIBEL_API_BEARER_TOKEN?: string | undefined;
+    DECIBEL_SUBACCOUNT_ADDRESS?: string | undefined;
+    DECIBEL_PACKAGE_ADDRESS?: string | undefined;
+    DECIBEL_NETWORK?: "testnet" | "mainnet" | undefined;
+    AEVO_API_KEY?: string | undefined;
+    AEVO_API_SECRET?: string | undefined;
+    AEVO_SIGNING_KEY?: string | undefined;
+    AEVO_ACCOUNT_PRIVATE_KEY?: string | undefined;
+    AEVO_NETWORK?: "testnet" | "mainnet" | undefined;
+    ORDERLY_BROKER_ID?: string | undefined;
+    ORDERLY_CHAIN_ID?: string | undefined;
+    ORDERLY_ACCOUNT_ID?: string | undefined;
+    ORDERLY_KEY?: string | undefined;
+    ORDERLY_SECRET?: string | undefined;
+    ORDERLY_TRADING_KEY?: string | undefined;
+    ORDERLY_TRADING_SECRET?: string | undefined;
+    ORDERLY_NETWORK?: "testnet" | "mainnet" | undefined;
+    PARADEX_API_BEARER_TOKEN?: string | undefined;
+    PARADEX_ACCOUNT_ADDRESS?: string | undefined;
+    PARADEX_PRIVATE_KEY?: string | undefined;
+    PARADEX_ETHEREUM_ACCOUNT?: string | undefined;
+    PARADEX_CHAIN_ID?: string | undefined;
+    PARADEX_NETWORK?: "testnet" | "mainnet" | undefined;
+    RISK_MAX_POSITION_SIZE_USD?: number | undefined;
+    RISK_MAX_TOTAL_EXPOSURE_USD?: number | undefined;
+    RISK_MAX_LEVERAGE?: number | undefined;
+    RISK_MIN_SIGNAL_CONFIDENCE?: number | undefined;
+    RISK_MAX_DRAWDOWN_PCT?: number | undefined;
+    RISK_DEFAULT_LEVERAGE?: number | undefined;
+    EXECUTION_STOP_LOSS_PCT?: number | undefined;
+    EXECUTION_TAKE_PROFIT_PCT?: number | undefined;
+    EXECUTION_SPREAD_OFFSET_PCT?: number | undefined;
+    OPERATOR_HEARTBEAT_INTERVAL_MS?: number | undefined;
+    PERPS_ALLOW_UNTRUSTED_ENDPOINTS?: "0" | "1" | "true" | "false" | undefined;
+    PERPS_BLOCKED_EXCHANGES?: string | undefined;
+    PERPS_BLOCKED_MARKETS?: string | undefined;
+    PERPS_BLOCKED_MARKET_PATTERNS?: string | undefined;
+    PERPS_REPUTATION_BLOCKLIST_FILE?: string | undefined;
+}>;
+export type EnvConfig = z.infer<typeof envSchema>;
+export declare function parseEnv(env: NodeJS.ProcessEnv): EnvConfig;