@exagent/agent 0.1.39 → 0.1.40

package/dist/index.d.ts

@@ -207,6 +207,108 @@ declare const PerpConfigSchema: z.ZodOptional<z.ZodObject<{
     allowedInstruments?: string[] | undefined;
 }>>;
 type PerpConfig$1 = z.infer<typeof PerpConfigSchema>;
+declare const PredictionConfigSchema: z.ZodOptional<z.ZodObject<{
+    /** Enable prediction market trading */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Polymarket CLOB API URL */
+    clobApiUrl: z.ZodDefault<z.ZodString>;
+    /** Gamma API URL for market discovery */
+    gammaApiUrl: z.ZodDefault<z.ZodString>;
+    /** Polygon RPC URL */
+    polygonRpcUrl: z.ZodOptional<z.ZodString>;
+    /** CLOB API key (L2 auth) — derived from wallet signature if not provided */
+    clobApiKey: z.ZodOptional<z.ZodString>;
+    /** CLOB API secret (L2 auth) */
+    clobApiSecret: z.ZodOptional<z.ZodString>;
+    /** CLOB API passphrase (L2 auth) */
+    clobApiPassphrase: z.ZodOptional<z.ZodString>;
+    /** Private key for the prediction relayer (calls recordPerpTrade on Base). Falls back to agent wallet. */
+    predictionRelayerKey: z.ZodOptional<z.ZodString>;
+    /** Maximum notional per trade in USD (default: 500) */
+    maxNotionalUSD: z.ZodDefault<z.ZodNumber>;
+    /** Maximum total exposure across all markets in USD (default: 5000) */
+    maxTotalExposureUSD: z.ZodDefault<z.ZodNumber>;
+    /** Target USDC allocation on Polygon in USD (default: 100) */
+    polygonAllocationUSD: z.ZodDefault<z.ZodNumber>;
+    /** Allowed market categories (empty = all categories) */
+    allowedCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Fee bridge threshold in USD — accumulated fees are bridged to Base when exceeded (default: 10) */
+    feeBridgeThresholdUSD: z.ZodDefault<z.ZodNumber>;
+    /** Prediction vault configuration (ERC-4626 + ERC-1271 on Polygon) */
+    vault: z.ZodOptional<z.ZodObject<{
+        /** Enable vault mode for prediction trading */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** PredictionVaultFactory address on Polygon */
+        factoryAddress: z.ZodString;
+        /** PredictionFeeCollector address on Polygon */
+        feeCollectorAddress: z.ZodOptional<z.ZodString>;
+        /** Existing vault address (if already created) */
+        vaultAddress: z.ZodOptional<z.ZodString>;
+        /** Agent's fee recipient address */
+        feeRecipient: z.ZodOptional<z.ZodString>;
+        /** Whether agent is verified (higher deposit cap) */
+        isVerified: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        factoryAddress: string;
+        isVerified: boolean;
+        feeRecipient?: string | undefined;
+        feeCollectorAddress?: string | undefined;
+        vaultAddress?: string | undefined;
+    }, {
+        factoryAddress: string;
+        feeRecipient?: string | undefined;
+        enabled?: boolean | undefined;
+        feeCollectorAddress?: string | undefined;
+        vaultAddress?: string | undefined;
+        isVerified?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    maxNotionalUSD: number;
+    clobApiUrl: string;
+    gammaApiUrl: string;
+    maxTotalExposureUSD: number;
+    polygonAllocationUSD: number;
+    feeBridgeThresholdUSD: number;
+    vault?: {
+        enabled: boolean;
+        factoryAddress: string;
+        isVerified: boolean;
+        feeRecipient?: string | undefined;
+        feeCollectorAddress?: string | undefined;
+        vaultAddress?: string | undefined;
+    } | undefined;
+    polygonRpcUrl?: string | undefined;
+    clobApiKey?: string | undefined;
+    clobApiSecret?: string | undefined;
+    clobApiPassphrase?: string | undefined;
+    predictionRelayerKey?: string | undefined;
+    allowedCategories?: string[] | undefined;
+}, {
+    vault?: {
+        factoryAddress: string;
+        feeRecipient?: string | undefined;
+        enabled?: boolean | undefined;
+        feeCollectorAddress?: string | undefined;
+        vaultAddress?: string | undefined;
+        isVerified?: boolean | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    maxNotionalUSD?: number | undefined;
+    clobApiUrl?: string | undefined;
+    gammaApiUrl?: string | undefined;
+    polygonRpcUrl?: string | undefined;
+    clobApiKey?: string | undefined;
+    clobApiSecret?: string | undefined;
+    clobApiPassphrase?: string | undefined;
+    predictionRelayerKey?: string | undefined;
+    maxTotalExposureUSD?: number | undefined;
+    polygonAllocationUSD?: number | undefined;
+    allowedCategories?: string[] | undefined;
+    feeBridgeThresholdUSD?: number | undefined;
+}>>;
+type PredictionConfig$1 = z.infer<typeof PredictionConfigSchema>;
 declare const AgentConfigSchema: z.ZodObject<{
     agentId: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
     name: z.ZodString;
@@ -338,11 +440,112 @@ declare const AgentConfigSchema: z.ZodObject<{
         maxNotionalUSD?: number | undefined;
         allowedInstruments?: string[] | undefined;
     }>>;
+    prediction: z.ZodOptional<z.ZodObject<{
+        /** Enable prediction market trading */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Polymarket CLOB API URL */
+        clobApiUrl: z.ZodDefault<z.ZodString>;
+        /** Gamma API URL for market discovery */
+        gammaApiUrl: z.ZodDefault<z.ZodString>;
+        /** Polygon RPC URL */
+        polygonRpcUrl: z.ZodOptional<z.ZodString>;
+        /** CLOB API key (L2 auth) — derived from wallet signature if not provided */
+        clobApiKey: z.ZodOptional<z.ZodString>;
+        /** CLOB API secret (L2 auth) */
+        clobApiSecret: z.ZodOptional<z.ZodString>;
+        /** CLOB API passphrase (L2 auth) */
+        clobApiPassphrase: z.ZodOptional<z.ZodString>;
+        /** Private key for the prediction relayer (calls recordPerpTrade on Base). Falls back to agent wallet. */
+        predictionRelayerKey: z.ZodOptional<z.ZodString>;
+        /** Maximum notional per trade in USD (default: 500) */
+        maxNotionalUSD: z.ZodDefault<z.ZodNumber>;
+        /** Maximum total exposure across all markets in USD (default: 5000) */
+        maxTotalExposureUSD: z.ZodDefault<z.ZodNumber>;
+        /** Target USDC allocation on Polygon in USD (default: 100) */
+        polygonAllocationUSD: z.ZodDefault<z.ZodNumber>;
+        /** Allowed market categories (empty = all categories) */
+        allowedCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Fee bridge threshold in USD — accumulated fees are bridged to Base when exceeded (default: 10) */
+        feeBridgeThresholdUSD: z.ZodDefault<z.ZodNumber>;
+        /** Prediction vault configuration (ERC-4626 + ERC-1271 on Polygon) */
+        vault: z.ZodOptional<z.ZodObject<{
+            /** Enable vault mode for prediction trading */
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** PredictionVaultFactory address on Polygon */
+            factoryAddress: z.ZodString;
+            /** PredictionFeeCollector address on Polygon */
+            feeCollectorAddress: z.ZodOptional<z.ZodString>;
+            /** Existing vault address (if already created) */
+            vaultAddress: z.ZodOptional<z.ZodString>;
+            /** Agent's fee recipient address */
+            feeRecipient: z.ZodOptional<z.ZodString>;
+            /** Whether agent is verified (higher deposit cap) */
+            isVerified: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            factoryAddress: string;
+            isVerified: boolean;
+            feeRecipient?: string | undefined;
+            feeCollectorAddress?: string | undefined;
+            vaultAddress?: string | undefined;
+        }, {
+            factoryAddress: string;
+            feeRecipient?: string | undefined;
+            enabled?: boolean | undefined;
+            feeCollectorAddress?: string | undefined;
+            vaultAddress?: string | undefined;
+            isVerified?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxNotionalUSD: number;
+        clobApiUrl: string;
+        gammaApiUrl: string;
+        maxTotalExposureUSD: number;
+        polygonAllocationUSD: number;
+        feeBridgeThresholdUSD: number;
+        vault?: {
+            enabled: boolean;
+            factoryAddress: string;
+            isVerified: boolean;
+            feeRecipient?: string | undefined;
+            feeCollectorAddress?: string | undefined;
+            vaultAddress?: string | undefined;
+        } | undefined;
+        polygonRpcUrl?: string | undefined;
+        clobApiKey?: string | undefined;
+        clobApiSecret?: string | undefined;
+        clobApiPassphrase?: string | undefined;
+        predictionRelayerKey?: string | undefined;
+        allowedCategories?: string[] | undefined;
+    }, {
+        vault?: {
+            factoryAddress: string;
+            feeRecipient?: string | undefined;
+            enabled?: boolean | undefined;
+            feeCollectorAddress?: string | undefined;
+            vaultAddress?: string | undefined;
+            isVerified?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
+        maxNotionalUSD?: number | undefined;
+        clobApiUrl?: string | undefined;
+        gammaApiUrl?: string | undefined;
+        polygonRpcUrl?: string | undefined;
+        clobApiKey?: string | undefined;
+        clobApiSecret?: string | undefined;
+        clobApiPassphrase?: string | undefined;
+        predictionRelayerKey?: string | undefined;
+        maxTotalExposureUSD?: number | undefined;
+        polygonAllocationUSD?: number | undefined;
+        allowedCategories?: string[] | undefined;
+        feeBridgeThresholdUSD?: number | undefined;
+    }>>;
     allowedTokens: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
+    agentId: string | number;
     name: string;
     network: "mainnet";
-    agentId: string | number;
     llm: {
         provider: "custom" | "openai" | "anthropic" | "google" | "deepseek" | "mistral" | "groq" | "together" | "ollama";
         temperature: number;
@@ -387,10 +590,33 @@ declare const AgentConfigSchema: z.ZodObject<{
         perpRelayerKey?: string | undefined;
         allowedInstruments?: string[] | undefined;
     } | undefined;
+    prediction?: {
+        enabled: boolean;
+        maxNotionalUSD: number;
+        clobApiUrl: string;
+        gammaApiUrl: string;
+        maxTotalExposureUSD: number;
+        polygonAllocationUSD: number;
+        feeBridgeThresholdUSD: number;
+        vault?: {
+            enabled: boolean;
+            factoryAddress: string;
+            isVerified: boolean;
+            feeRecipient?: string | undefined;
+            feeCollectorAddress?: string | undefined;
+            vaultAddress?: string | undefined;
+        } | undefined;
+        polygonRpcUrl?: string | undefined;
+        clobApiKey?: string | undefined;
+        clobApiSecret?: string | undefined;
+        clobApiPassphrase?: string | undefined;
+        predictionRelayerKey?: string | undefined;
+        allowedCategories?: string[] | undefined;
+    } | undefined;
     allowedTokens?: string[] | undefined;
 }, {
-    name: string;
     agentId: string | number;
+    name: string;
     llm: {
         provider: "custom" | "openai" | "anthropic" | "google" | "deepseek" | "mistral" | "groq" | "together" | "ollama";
         model?: string | undefined;
@@ -436,6 +662,29 @@ declare const AgentConfigSchema: z.ZodObject<{
         maxNotionalUSD?: number | undefined;
         allowedInstruments?: string[] | undefined;
     } | undefined;
+    prediction?: {
+        vault?: {
+            factoryAddress: string;
+            feeRecipient?: string | undefined;
+            enabled?: boolean | undefined;
+            feeCollectorAddress?: string | undefined;
+            vaultAddress?: string | undefined;
+            isVerified?: boolean | undefined;
+        } | undefined;
+        enabled?: boolean | undefined;
+        maxNotionalUSD?: number | undefined;
+        clobApiUrl?: string | undefined;
+        gammaApiUrl?: string | undefined;
+        polygonRpcUrl?: string | undefined;
+        clobApiKey?: string | undefined;
+        clobApiSecret?: string | undefined;
+        clobApiPassphrase?: string | undefined;
+        predictionRelayerKey?: string | undefined;
+        maxTotalExposureUSD?: number | undefined;
+        polygonAllocationUSD?: number | undefined;
+        allowedCategories?: string[] | undefined;
+        feeBridgeThresholdUSD?: number | undefined;
+    } | undefined;
     allowedTokens?: string[] | undefined;
 }>;
 type AgentConfig = z.infer<typeof AgentConfigSchema>;
@@ -681,13 +930,13 @@ declare class VaultManager {
  * Used by both the SDK relay client and the API relay service.
  */
 type AgentMode = 'idle' | 'trading' | 'paper';
-type CommandType = 'start_trading' | 'stop_trading' | 'start_paper_trading' | 'stop_paper_trading' | 'enable_hyperliquid' | 'disable_hyperliquid' | 'start_perp_trading' | 'stop_perp_trading' | 'update_risk_params' | 'update_perp_params' | 'update_trading_interval' | 'create_vault' | 'refresh_status' | 'shutdown';
+type CommandType = 'start_trading' | 'stop_trading' | 'start_paper_trading' | 'stop_paper_trading' | 'enable_hyperliquid' | 'disable_hyperliquid' | 'start_perp_trading' | 'stop_perp_trading' | 'enable_polymarket' | 'disable_polymarket' | 'start_prediction_trading' | 'stop_prediction_trading' | 'create_prediction_vault' | 'deposit_prediction_vault' | 'withdraw_prediction_vault' | 'update_risk_params' | 'update_perp_params' | 'update_prediction_params' | 'update_trading_interval' | 'create_vault' | 'refresh_status' | 'shutdown';
 interface RelayCommand {
     id: string;
     type: CommandType;
     params?: Record<string, unknown>;
 }
-type MessageType = 'trade_executed' | 'trade_failed' | 'paper_trade_executed' | 'paper_trade_failed' | 'perp_fill' | 'perp_liquidation_warning' | 'perp_funding' | 'funds_low' | 'risk_limit_hit' | 'vault_created' | 'config_updated' | 'llm_error' | 'command_result' | 'system';
+type MessageType = 'trade_executed' | 'trade_failed' | 'paper_trade_executed' | 'paper_trade_failed' | 'perp_fill' | 'perp_liquidation_warning' | 'perp_funding' | 'prediction_fill' | 'prediction_market_resolved' | 'prediction_vault_created' | 'prediction_vault_deposit' | 'prediction_vault_withdraw' | 'funds_low' | 'risk_limit_hit' | 'vault_created' | 'config_updated' | 'llm_error' | 'command_result' | 'system';
 type MessageLevel = 'info' | 'warning' | 'error' | 'success';
 interface AgentStatusPayload {
     mode: AgentMode;
@@ -726,6 +975,28 @@ interface AgentStatusPayload {
         effectiveLeverage: number;
         pendingRecords: number;
     };
+    prediction?: {
+        enabled: boolean;
+        trading: boolean;
+        polygonUSDC: number;
+        baseUSDC: number;
+        totalExposure: number;
+        openMarkets: number;
+        openPositions: number;
+        unrealizedPnl: number;
+        pendingFees: number;
+        pendingRecords: number;
+        /** Prediction vault status (only present in vault mode) */
+        vault?: {
+            address: string;
+            totalAssets: number;
+            sharePrice: number;
+            cachedCtfValue: number;
+            currentExposureBps: number;
+            circuitBreakerActive: boolean;
+            isPaused: boolean;
+        };
+    };
     /** Spot position tracking summary (auto-populated by PositionTracker) */
     positions?: {
         openPositions: number;
@@ -821,6 +1092,23 @@ declare class AgentRuntime {
     private cachedPerpMarginUsed;
     private cachedPerpLeverage;
     private cachedPerpOpenPositions;
+    private predictionClient;
+    private predictionOrders;
+    private predictionPositions;
+    private predictionRecorder;
+    private predictionFunding;
+    private predictionBrowser;
+    private predictionStrategy;
+    private predictionConnected;
+    private predictionTradingActive;
+    private cachedPredictionPolygonUSDC;
+    private cachedPredictionBaseUSDC;
+    private cachedPredictionExposure;
+    private cachedPredictionOpenMarkets;
+    private cachedPredictionOpenPositions;
+    private cachedPredictionUnrealizedPnl;
+    private predictionVaultManager;
+    private cachedPredictionVaultStatus;
     constructor(config: RuntimeConfig, options?: {
         paperMode?: boolean;
         paperBalances?: Record<string, bigint>;
@@ -844,6 +1132,11 @@ declare class AgentRuntime {
      * Only initializes if perp is enabled in config AND risk universe >= 2.
      */
     private initializePerp;
+    /**
+     * Initialize Polymarket prediction market components.
+     * Only initializes if prediction is enabled in config AND risk universe >= 2.
+     */
+    private initializePrediction;
     /**
      * Ensure the current wallet is linked to the agent.
      * If the trading wallet differs from the owner, enters a recovery loop
@@ -898,6 +1191,21 @@ declare class AgentRuntime {
      * Called from sendRelayStatus at most every 2.5 minutes (timestamp-throttled).
      */
     private checkPendingConfigApproval;
+    /**
+     * Periodically sync config hash from on-chain to detect external changes.
+     * This catches cases where the config was changed via the website or another
+     * session while this agent is running. Without this, all trades and recordings
+     * fail with ConfigMismatch until the agent is restarted.
+     *
+     * Called from sendRelayStatus at most every 5 minutes (timestamp-throttled).
+     */
+    private lastConfigSyncAt;
+    private syncConfigHashFromChain;
+    /**
+     * Propagate a config hash update to runtime + all consumers (recorders).
+     * Ensures executor, perp recorder, and prediction recorder all stay in sync.
+     */
+    private updateConfigHashEverywhere;
     /**
      * Send current status to the relay
      */
@@ -912,6 +1220,12 @@ declare class AgentRuntime {
      * Fills arrive async via WebSocket and are auto-recorded on Base.
      */
     private runPerpCycle;
+    /**
+     * Run a single prediction market trading cycle.
+     * Fetches active markets, positions, calls prediction strategy, executes signals.
+     * Fills are recorded on Base via Router.recordPerpTrade() with POLY: prefix.
+     */
+    private runPredictionCycle;
     /**
      * Check if ETH balance is below threshold and notify.
      * Returns true if trading should continue, false if ETH is critically low.
@@ -2195,6 +2509,737 @@ interface OnboardingStatus {
     builderFeeBps: number;
 }
 
+/**
+ * Polymarket Prediction Market Types
+ *
+ * Core type definitions for prediction market trading via Polymarket CLOB on Polygon.
+ * Agents record fills on-chain via Router.recordPerpTrade() with a POLY: instrument prefix
+ * for leaderboard attribution.
+ */
+
+interface PredictionConfig {
+    /** Enable prediction market trading */
+    enabled: boolean;
+    /** Polymarket CLOB API URL */
+    clobApiUrl: string;
+    /** Polymarket Gamma API URL (market discovery) */
+    gammaApiUrl: string;
+    /** Polygon RPC URL for balance queries and CCTP bridging */
+    polygonRpcUrl: string;
+    /** Private key for the prediction relayer (calls recordPerpTrade on Base). Falls back to agent wallet. */
+    predictionRelayerKey?: string;
+    /** Maximum notional per single trade in USD (default: 1000) */
+    maxNotionalUSD: number;
+    /** Maximum total exposure across all prediction markets in USD (default: 5000) */
+    maxTotalExposureUSD: number;
+    /** Target USDC allocation on Polygon in USD (default: 100) */
+    polygonAllocationUSD: number;
+    /** Allowed market categories (if empty, all categories). e.g. ["crypto", "politics", "sports"] */
+    allowedCategories?: string[];
+    /** Fee threshold in USD before triggering CCTP bridge to Base treasury (default: 10) */
+    feeBridgeThresholdUSD: number;
+}
+type PredictionAction = 'buy_yes' | 'buy_no' | 'sell_yes' | 'sell_no' | 'hold';
+interface PredictionTradeSignal {
+    /** Trading action */
+    action: PredictionAction;
+    /** Polymarket condition ID */
+    marketConditionId: string;
+    /** Human-readable market question (for logging/relay) */
+    marketQuestion: string;
+    /** Outcome index (0 = YES, 1 = NO for binary markets) */
+    outcomeIndex: number;
+    /** USDC amount to spend (for buy) or shares to sell (for sell) */
+    amount: number;
+    /** Limit price (0.01 - 0.99, represents probability) */
+    limitPrice: number;
+    /** Order type */
+    orderType: 'limit' | 'market';
+    /** Signal confidence (0.0 - 1.0) */
+    confidence: number;
+    /** LLM reasoning for this signal */
+    reasoning?: string;
+}
+interface PredictionPosition {
+    /** Polymarket condition ID */
+    marketConditionId: string;
+    /** Human-readable market question */
+    marketQuestion: string;
+    /** Outcome index (0 = YES, 1 = NO) */
+    outcomeIndex: number;
+    /** Outcome label ("Yes" or "No") */
+    outcomeLabel: string;
+    /** CTF token ID (ERC-1155) */
+    tokenId: string;
+    /** Number of outcome tokens held */
+    balance: number;
+    /** Average price paid per token (0-1) */
+    averageEntryPrice: number;
+    /** Current market price (0-1) */
+    currentPrice: number;
+    /** Unrealized PnL in USD: (currentPrice - averageEntryPrice) * balance */
+    unrealizedPnl: number;
+    /** Total USDC spent acquiring this position */
+    costBasis: number;
+    /** Market end date (unix timestamp) */
+    endDate?: number;
+    /** Market category (e.g., "crypto", "politics") */
+    category?: string;
+}
+interface PredictionMarket {
+    /** Polymarket condition ID */
+    conditionId: string;
+    /** Market question (e.g., "Will ETH hit $5000 by July?") */
+    question: string;
+    /** Market description */
+    description: string;
+    /** Category (e.g., "Crypto", "Politics", "Sports") */
+    category: string;
+    /** Outcome labels */
+    outcomes: string[];
+    /** Outcome token IDs (corresponding to outcomes array) */
+    outcomeTokenIds: string[];
+    /** Current prices for each outcome (0-1, sums to ~1) */
+    outcomePrices: number[];
+    /** 24h trading volume in USD */
+    volume24h: number;
+    /** Total liquidity in USD */
+    liquidity: number;
+    /** Market end/resolution date (unix timestamp) */
+    endDate: number;
+    /** Whether the market is still active for trading */
+    active: boolean;
+    /** Whether the market has been resolved */
+    resolved: boolean;
+    /** Winning outcome index (only set if resolved) */
+    winningOutcome?: number;
+    /** Resolution source URL */
+    resolutionSource?: string;
+    /** Number of unique traders */
+    uniqueTraders?: number;
+}
+interface PredictionFill {
+    /** Polymarket order ID */
+    orderId: string;
+    /** Polymarket trade ID (unique per fill) */
+    tradeId: string;
+    /** Condition ID */
+    marketConditionId: string;
+    /** Outcome index */
+    outcomeIndex: number;
+    /** Direction */
+    side: 'BUY' | 'SELL';
+    /** Fill price (0-1) */
+    price: string;
+    /** Fill size (number of outcome tokens) */
+    size: string;
+    /** Fee paid in USDC */
+    fee: string;
+    /** Fill timestamp (ms) */
+    timestamp: number;
+    /** Market question (for display) */
+    marketQuestion?: string;
+    /** Whether this was a maker fill */
+    isMaker: boolean;
+    /** CTF token ID (ERC-1155) for this outcome — used for CLOB price lookups */
+    tokenId?: string;
+}
+interface PredictionOrderResult {
+    /** Whether the order was accepted */
+    success: boolean;
+    /** Polymarket order ID */
+    orderId?: string;
+    /** Fill status */
+    status: 'filled' | 'partially_filled' | 'resting' | 'cancelled' | 'error';
+    /** Average fill price (if filled or partially filled) */
+    avgPrice?: number;
+    /** Total filled size */
+    filledSize?: number;
+    /** Error message (if error) */
+    error?: string;
+}
+interface PredictionAccountSummary {
+    /** USDC balance on Polygon */
+    polygonUSDC: number;
+    /** USDC balance on Base */
+    baseUSDC: number;
+    /** Total cost basis of all open prediction positions */
+    totalExposure: number;
+    /** Total unrealized PnL across all prediction positions */
+    totalUnrealizedPnl: number;
+    /** Number of markets with open positions */
+    openMarketCount: number;
+    /** Number of individual outcome positions */
+    openPositionCount: number;
+    /** Accumulated fees pending bridge to Base treasury */
+    pendingFees: number;
+}
+interface RecordPredictionTradeParams {
+    agentId: bigint;
+    configHash: `0x${string}`;
+    /** Encoded instrument: "POLY:{conditionId}:{outcomeIndex}" */
+    instrument: string;
+    /** true = BUY, false = SELL */
+    isLong: boolean;
+    /** USDC amount (6-decimal) */
+    notionalUSD: bigint;
+    /** Platform fee 0.2% (6-decimal) */
+    feeUSD: bigint;
+    /** keccak256(polymarketTradeId) */
+    fillId: `0x${string}`;
+}
+/**
+ * Prediction market strategy function signature.
+ * Called once per prediction trading cycle.
+ *
+ * @param markets - Active prediction markets (filtered by config categories)
+ * @param positions - Current open prediction positions
+ * @param account - Account balances and exposure summary
+ * @param llm - LLM adapter for reasoning
+ * @param config - Agent configuration
+ * @returns Array of prediction trade signals
+ */
+type PredictionStrategyFunction = (markets: PredictionMarket[], positions: PredictionPosition[], account: PredictionAccountSummary, llm: LLMAdapter, config: Record<string, unknown>) => Promise<PredictionTradeSignal[]>;
+
+/**
+ * Polymarket Client
+ *
+ * Wraps the @polymarket/clob-client for CLOB interaction (orders, positions)
+ * and the Gamma API for market discovery (browsing, search, trending).
+ *
+ * Key details:
+ * - CLOB is on Polygon (chain 137) — orders are off-chain, settlement is on-chain
+ * - Gamma API is public/unauthenticated — used for market metadata
+ * - EOA signing (SignatureType 0) — agent private key signs directly
+ * - API key (L2 auth) derived once per session from wallet signature
+ */
+
+declare class PolymarketClient {
+    private readonly config;
+    private clobClient;
+    private apiCreds;
+    private readonly signer;
+    private readonly walletAddress;
+    /** Vault mode: when true, orders use maker=vaultAddress with POLY_GNOSIS_SAFE signature type */
+    private readonly vaultMode;
+    /** Vault contract address (only set in vault mode) */
+    private readonly vaultAddress;
+    /** Cache for Gamma API market data (conditionId -> market) */
+    private marketCache;
+    private readonly CACHE_TTL_MS;
+    constructor(privateKey: string, config?: Partial<PredictionConfig>, vaultOpts?: {
+        /** Enable vault mode (maker=vaultAddress, signatureType=POLY_GNOSIS_SAFE) */
+        vaultMode: boolean;
+        /** Vault contract address on Polygon */
+        vaultAddress: string;
+    });
+    /**
+     * Initialize the CLOB client with L2 API credentials.
+     * Must be called once before placing orders.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the client is initialized with CLOB credentials.
+     */
+    get isInitialized(): boolean;
+    /**
+     * Get the order book for a specific outcome token.
+     */
+    getOrderBook(tokenId: string): Promise<{
+        bids: OrderBookLevel[];
+        asks: OrderBookLevel[];
+    }>;
+    /**
+     * Get the midpoint price for an outcome token.
+     */
+    getMidpointPrice(tokenId: string): Promise<number>;
+    /**
+     * Get the last trade price for an outcome token.
+     */
+    getLastTradePrice(tokenId: string): Promise<number>;
+    /**
+     * Place a limit order on the CLOB.
+     */
+    placeLimitOrder(params: {
+        tokenId: string;
+        price: number;
+        size: number;
+        side: 'BUY' | 'SELL';
+    }): Promise<{
+        orderId: string;
+        success: boolean;
+    }>;
+    /**
+     * Place a market order (aggressive limit at best available price).
+     */
+    placeMarketOrder(params: {
+        tokenId: string;
+        amount: number;
+        side: 'BUY' | 'SELL';
+    }): Promise<{
+        orderId: string;
+        success: boolean;
+    }>;
+    /**
+     * Cancel an open order by ID.
+     */
+    cancelOrder(orderId: string): Promise<boolean>;
+    /**
+     * Cancel all open orders.
+     */
+    cancelAllOrders(): Promise<boolean>;
+    /**
+     * Get open orders for the agent's wallet.
+     */
+    getOpenOrders(): Promise<any[]>;
+    /**
+     * Get trade history (fills) for the agent's wallet.
+     */
+    getTradeHistory(): Promise<PredictionFill[]>;
+    /**
+     * Get active prediction markets from Gamma API.
+     */
+    getMarkets(params?: {
+        limit?: number;
+        offset?: number;
+        category?: string;
+        active?: boolean;
+    }): Promise<PredictionMarket[]>;
+    /**
+     * Get a single market by condition ID.
+     */
+    getMarketByConditionId(conditionId: string): Promise<PredictionMarket | null>;
+    /**
+     * Search markets by query string.
+     */
+    searchMarkets(query: string, limit?: number): Promise<PredictionMarket[]>;
+    /**
+     * Get trending markets sorted by volume.
+     */
+    getTrendingMarkets(limit?: number): Promise<PredictionMarket[]>;
+    getWalletAddress(): string;
+    /**
+     * Get the effective maker address for CLOB orders.
+     * In vault mode, this is the vault contract address.
+     * In normal mode, this is the agent's EOA address.
+     */
+    getMakerAddress(): string;
+    /**
+     * Whether the client is operating in vault mode.
+     */
+    get isVaultMode(): boolean;
+    /**
+     * Get the vault address (null if not in vault mode).
+     */
+    getVaultAddress(): string | undefined;
+    private ensureInitialized;
+    private parseGammaMarket;
+    private parseRawFill;
+}
+interface OrderBookLevel {
+    price: number;
+    size: number;
+}
+
+/**
+ * Polymarket Trade ID → bytes32 Helpers
+ *
+ * Converts Polymarket trade/order IDs to bytes32 fill IDs for on-chain recording
+ * via Router.recordPerpTrade(). Uses keccak256 hashing for consistent 32-byte output.
+ *
+ * Unlike Hyperliquid (which has its own EIP-712 signing domain), Polymarket signing
+ * is handled internally by @polymarket/clob-client. This module only handles the
+ * trade-to-fillId conversion needed for on-chain deduplication.
+ */
+/**
+ * Convert a Polymarket trade ID to a bytes32 fill ID for on-chain recording.
+ * Uses keccak256 to ensure consistent 32-byte output.
+ *
+ * @param tradeId - Polymarket trade/order ID string
+ * @returns bytes32 hex string for Router.recordPerpTrade fillId param
+ */
+declare function tradeIdToBytes32(tradeId: string): `0x${string}`;
+/**
+ * Convert a Polymarket order ID to a bytes32 fill ID (fallback).
+ */
+declare function orderIdToBytes32(orderId: string): `0x${string}`;
+/**
+ * Encode a prediction trade as a Router.recordPerpTrade instrument string.
+ *
+ * Format: "POLY:{conditionId}:{outcomeIndex}"
+ * Example: "POLY:0x1a2b3c4d5e6f7890:0"
+ *
+ * The indexer detects the "POLY:" prefix and routes to the prediction tables,
+ * parsing the conditionId and outcomeIndex from the string.
+ *
+ * @param conditionId - Polymarket condition ID (hex string)
+ * @param outcomeIndex - 0 = YES, 1 = NO (for binary markets)
+ */
+declare function encodePredictionInstrument(conditionId: string, outcomeIndex: number): string;
+/**
+ * Decode a POLY: instrument string back to its components.
+ * Returns null if the string is not a valid prediction instrument.
+ *
+ * @param instrument - Router instrument string (e.g., "POLY:0x1a2b3c4d5e6f7890:0")
+ */
+declare function decodePredictionInstrument(instrument: string): {
+    conditionId: string;
+    outcomeIndex: number;
+} | null;
+/**
+ * Calculate the platform fee for a prediction trade.
+ * Fee rate: 0.2% (20 basis points) of notional.
+ *
+ * @param notionalUSD - Trade notional in 6-decimal format (e.g., 65_000000 = $65)
+ * @returns Fee amount in 6-decimal format
+ */
+declare function calculatePredictionFee(notionalUSD: bigint): bigint;
+
+/**
+ * Polymarket Order Management
+ *
+ * Handles order placement and cancellation on the Polymarket CLOB.
+ * Wraps PolymarketClient with trade signal processing and fill tracking.
+ *
+ * Orders are placed on Polygon via the CLOB REST API.
+ * Fills are then recorded on Base via the recorder module.
+ */
+
+declare class PredictionOrderManager {
+    private readonly client;
+    private readonly config;
+    /** Recent fills tracked for recording */
+    private readonly recentFills;
+    private readonly MAX_RECENT_FILLS;
+    constructor(client: PolymarketClient, config: PredictionConfig);
+    /**
+     * Execute a prediction trade signal.
+     * Routes to limit or market order based on signal.orderType.
+     */
+    executeSignal(signal: PredictionTradeSignal): Promise<PredictionOrderResult>;
+    /**
+     * Cancel an open order by ID.
+     */
+    cancelOrder(orderId: string): Promise<boolean>;
+    /**
+     * Cancel all open orders.
+     */
+    cancelAllOrders(): Promise<boolean>;
+    /**
+     * Poll for new fills since last check.
+     * Returns fills that haven't been seen before.
+     */
+    pollNewFills(): Promise<PredictionFill[]>;
+    /**
+     * Get recent fills (from local cache).
+     */
+    getRecentFills(): PredictionFill[];
+    /**
+     * Check if a signal violates risk limits.
+     * Returns error string if violated, null if OK.
+     */
+    private checkRiskLimits;
+}
+
+/**
+ * Polymarket Position Tracking
+ *
+ * Tracks CTF token balances on Polygon and calculates unrealized PnL.
+ * Positions are ERC-1155 tokens representing market outcomes.
+ *
+ * Cost basis is tracked locally (CLOB fills → entry prices).
+ * Current prices are fetched from the CLOB order book.
+ */
+
+declare class PredictionPositionManager {
+    private readonly client;
+    private readonly config;
+    /** Local position tracking (conditionId:outcomeIndex -> position data) */
+    private positions;
+    /** Cache TTL */
+    private lastPriceRefresh;
+    private readonly PRICE_REFRESH_MS;
+    constructor(client: PolymarketClient, config: PredictionConfig);
+    /**
+     * Get all open prediction positions with current prices.
+     */
+    getPositions(forceRefresh?: boolean): Promise<PredictionPosition[]>;
+    /**
+     * Get a specific position.
+     */
+    getPosition(conditionId: string, outcomeIndex: number): Promise<PredictionPosition | null>;
+    /**
+     * Get account summary (balances, exposure, PnL).
+     */
+    getAccountSummary(): Promise<PredictionAccountSummary>;
+    /**
+     * Get total exposure across all positions.
+     */
+    getTotalExposure(): number;
+    /**
+     * Get total unrealized PnL.
+     */
+    getTotalUnrealizedPnl(): number;
+    /**
+     * Process a fill and update position tracking.
+     * Called when a new fill is detected by the order manager.
+     */
+    processFill(fill: PredictionFill): void;
+    /**
+     * Process multiple fills (batch update).
+     */
+    processFills(fills: PredictionFill[]): void;
+    /**
+     * Mark a market as resolved. Positions settle at $0 or $1.
+     */
+    resolveMarket(conditionId: string, winningOutcome: number): void;
+    /**
+     * Export position state for persistence across restarts.
+     */
+    exportState(): LocalPosition[];
+    /**
+     * Import position state from previous session.
+     */
+    importState(state: LocalPosition[]): void;
+    /**
+     * Refresh current prices for all open positions from CLOB.
+     */
+    private refreshPrices;
+    private toExternalPosition;
+}
+interface LocalPosition {
+    marketConditionId: string;
+    outcomeIndex: number;
+    marketQuestion: string;
+    tokenId: string;
+    balance: number;
+    totalBought: number;
+    totalSold: number;
+    totalCostBasis: number;
+    totalProceeds: number;
+    averageEntryPrice: number;
+    currentPrice: number;
+    category?: string;
+    endDate?: number;
+}
+
+/**
+ * Prediction Trade Recorder
+ *
+ * Records Polymarket prediction fills on Base via Router.recordPerpTrade().
+ * Uses the POLY: instrument prefix convention so the indexer can route
+ * prediction trades to dedicated tables.
+ *
+ * This is a direct adaptation of the perp/recorder.ts pattern:
+ * - Each fill is individually recorded on-chain
+ * - Fill ID deduplication prevents double-recording (contract enforces)
+ * - Retry queue handles transient failures
+ * - notionalUSD = price * size * 1e6 (6-decimal)
+ * - feeUSD = notionalUSD * 20 / 10000 (0.2%, 6-decimal)
+ */
+
+declare class PredictionTradeRecorder {
+    private readonly publicClient;
+    private readonly walletClient;
+    private readonly account;
+    private readonly agentId;
+    private configHash;
+    /** Retry queue for failed recordings */
+    private retryQueue;
+    /** Set of fill IDs already recorded (or in-progress) to prevent local dups */
+    private recordedFills;
+    /** Timer for processing retry queue */
+    private retryTimer;
+    /** Accumulated fees pending bridge to Base treasury (in USD, 6-decimal) */
+    private accumulatedFees;
+    constructor(opts: {
+        privateKey: `0x${string}`;
+        rpcUrl?: string;
+        agentId: bigint;
+        configHash: `0x${string}`;
+    });
+    /**
+     * Record a prediction fill on-chain.
+     * Converts the Polymarket fill into recordPerpTrade params with POLY: prefix.
+     */
+    recordFill(fill: PredictionFill): Promise<{
+        success: boolean;
+        txHash?: string;
+        error?: string;
+    }>;
+    /**
+     * Update the config hash (when epoch changes).
+     */
+    updateConfigHash(configHash: `0x${string}`): void;
+    /**
+     * Get the number of fills pending retry.
+     */
+    get pendingRetries(): number;
+    /**
+     * Get the number of fills recorded (local dedup set size).
+     */
+    get recordedCount(): number;
+    /**
+     * Get accumulated fees pending bridge (6-decimal USD).
+     */
+    get pendingFees(): bigint;
+    /**
+     * Get accumulated fees as human-readable USD.
+     */
+    get pendingFeesUSD(): number;
+    /**
+     * Reset accumulated fees (after bridge to treasury).
+     */
+    resetAccumulatedFees(): void;
+    /**
+     * Stop the recorder (clear retry timer).
+     */
+    stop(): void;
+    /**
+     * Submit a recordPerpTrade transaction on Base.
+     */
+    private submitRecord;
+    /**
+     * Process the retry queue — attempt to re-submit failed recordings.
+     */
+    private processRetryQueue;
+    /**
+     * Calculate notional USD from a fill (6-decimal).
+     * notionalUSD = price * size * 1e6
+     */
+    private calculateNotionalUSD;
+}
+
+/**
+ * Polymarket Market Browser
+ *
+ * High-level interface for market discovery via the Gamma API.
+ * Used by the prediction strategy function to get curated market data
+ * for LLM consumption.
+ *
+ * The Gamma API is public and requires no authentication.
+ * Responses are cached for 60 seconds to reduce API load.
+ */
+
+/** Known Polymarket market categories */
+declare const MARKET_CATEGORIES: readonly ["crypto", "politics", "sports", "entertainment", "science", "business", "culture", "weather", "tech"];
+type MarketCategory = (typeof MARKET_CATEGORIES)[number];
+declare class MarketBrowser {
+    private readonly gammaUrl;
+    private readonly allowedCategories;
+    /** Cache for market listings */
+    private listCache;
+    private readonly CACHE_TTL_MS;
+    constructor(config?: Partial<PredictionConfig>);
+    /**
+     * Get active markets, optionally filtered by category.
+     * Results are sorted by volume (highest first).
+     */
+    getActiveMarkets(params?: {
+        category?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<PredictionMarket[]>;
+    /**
+     * Search markets by query text.
+     */
+    searchMarkets(query: string, limit?: number): Promise<PredictionMarket[]>;
+    /**
+     * Get trending markets (highest 24h volume).
+     */
+    getTrendingMarkets(limit?: number): Promise<PredictionMarket[]>;
+    /**
+     * Get markets expiring soon (within N days).
+     */
+    getExpiringMarkets(withinDays?: number, limit?: number): Promise<PredictionMarket[]>;
+    /**
+     * Get recently resolved markets (for PnL tracking).
+     */
+    getRecentlyResolved(limit?: number): Promise<PredictionMarket[]>;
+    /**
+     * Get a single market's details by condition ID.
+     */
+    getMarketDetail(conditionId: string): Promise<PredictionMarket | null>;
+    /**
+     * Build a concise market summary string for LLM context.
+     * Keeps the prompt token count manageable.
+     */
+    formatMarketsForLLM(markets: PredictionMarket[], maxMarkets?: number): string;
+    private fetchGamma;
+    private parseMarket;
+}
+
+/**
+ * Prediction Funding Module
+ *
+ * Manages USDC transfers between Base and Polygon using Circle's CCTP V2.
+ * Adapted from the Hyperliquid funding module (perp/funding.ts).
+ *
+ * Flow:
+ *   Deposit:  Base USDC → (CCTP burn) → Circle attestation → (CCTP mint) → Polygon USDC
+ *   Withdraw: Polygon USDC → (CCTP burn) → Circle attestation → (CCTP mint) → Base USDC
+ *
+ * Simpler than Hyperliquid funding because Polygon supports CCTP V2 directly —
+ * no intermediate chain or core deposit wallet needed.
+ */
+
+interface PredictionFundingConfig {
+    privateKey: `0x${string}`;
+    baseRpcUrl?: string;
+    polygonRpcUrl?: string;
+    /** Override mint recipient on Polygon (e.g., vault address in vault mode).
+     *  When set, depositToPolygon() sends USDC to this address instead of the agent EOA. */
+    polygonRecipient?: Address;
+}
+interface BridgeResult {
+    success: boolean;
+    amount: bigint;
+    burnTxHash?: Hash;
+    receiveTxHash?: Hash;
+    error?: string;
+    duration?: number;
+}
+type BridgeStep = 'approve_usdc' | 'cctp_burn' | 'wait_attestation' | 'cctp_receive';
+declare class PredictionFunding {
+    private readonly basePublic;
+    private readonly baseWallet;
+    private readonly polygonPublic;
+    private readonly polygonWallet;
+    private readonly account;
+    /** Override recipient for deposits to Polygon (vault address in vault mode) */
+    private readonly polygonRecipient;
+    constructor(config: PredictionFundingConfig);
+    /** Get USDC balance on Base (6-decimal) */
+    getBaseUSDCBalance(): Promise<bigint>;
+    /** Get USDC balance on Polygon (6-decimal) */
+    getPolygonUSDCBalance(): Promise<bigint>;
+    /** Get MATIC balance on Polygon for gas (wei) */
+    getPolygonGasBalance(): Promise<bigint>;
+    /**
+     * Bridge USDC from Base to Polygon via CCTP V2.
+     *
+     * Steps:
+     * 1. Approve USDC on Base for TokenMessengerV2
+     * 2. Call depositForBurn (Base → Polygon)
+     * 3. Wait for Circle attestation (~1-5 minutes)
+     * 4. Call receiveMessage on Polygon
+     */
+    depositToPolygon(amount: bigint, onStep?: (step: BridgeStep) => void): Promise<BridgeResult>;
+    /**
+     * Bridge USDC from Polygon back to Base via CCTP V2.
+     * Used for fee collection (bridge accumulated fees to Base treasury).
+     */
+    withdrawToBase(amount: bigint, onStep?: (step: BridgeStep) => void): Promise<BridgeResult>;
+    /** Convert address to bytes32 (left-padded) for CCTP mintRecipient */
+    private addressToBytes32;
+    /** Approve USDC spend if needed (maxUint256 pattern) */
+    private approveIfNeeded;
+    /** Extract MessageSent bytes from a CCTP burn transaction receipt */
+    private extractMessageFromReceipt;
+    /** Wait for Circle attestation (polls Iris API) */
+    private waitForAttestation;
+}
+
 /**
  * Secure Environment Storage
  *
@@ -2238,6 +3283,6 @@ declare function decryptEnvFile(encPath: string, passphrase: string): Record<str
 declare function loadSecureEnv(basePath: string, passphrase?: string): boolean;
 
 /** @exagent/agent package version — update alongside package.json */
-declare const AGENT_VERSION = "0.1.39";
+declare const AGENT_VERSION = "0.1.40";
 
-export { AGENT_VERSION, type AccountSummary, type AgentConfig, AgentConfigSchema, type AgentMode, AgentRuntime, type AgentStatusPayload, AnthropicAdapter, BaseLLMAdapter, type CommandType, DeepSeekAdapter, FileStore, type FillCallback, type FundingCallback, type FundingPayment, GoogleAdapter, GroqAdapter, HYPERLIQUID_DOMAIN, HyperliquidClient, HyperliquidSigner, HyperliquidWebSocket, type LLMAdapter, type LLMConfig, LLMConfigSchema, type LLMMessage, type LLMMetadata, type LLMProvider, LLMProviderSchema, type LLMResponse, type LiquidationCallback, type MarketData, MarketDataService, type MessageLevel, type MessageType, MistralAdapter, OllamaAdapter, type OnboardingStatus, OpenAIAdapter, OrderManager, type OrderResult, type PerpAction, type PerpConfig$1 as PerpConfig, PerpConfigSchema, type PerpFill, type PerpMarketData, PerpOnboarding, type PerpPosition, type PerpStrategyFunction, PerpTradeRecorder, type PerpTradeSignal, type PerpConfig as PerpTradingConfig, PositionManager, type PositionSummary, PositionTracker, type RecordPerpTradeParams, RelayClient, type RelayCommand, type RelayConfig$1 as RelayConfig, RelayConfigSchema, RiskManager, type RiskState, type RiskUniverse, RiskUniverseSchema, type RuntimeConfig, STRATEGY_TEMPLATES, type StrategyContext, type StrategyFunction, type StrategyStore, type StrategyTemplate, TogetherAdapter, type TrackedPosition, TradeExecutor, type TradeRecord, type TradeSignal, type TradingConfig, TradingConfigSchema, type VaultConfig, VaultConfigSchema, VaultManager, type VaultManagerConfig, type VaultPolicy, VaultPolicySchema, type VaultStatus, createLLMAdapter, createSampleConfig, decryptEnvFile, encryptEnvFile, fillHashToBytes32, fillOidToBytes32, getAllStrategyTemplates, getNextNonce, getStrategyTemplate, loadConfig, loadSecureEnv, loadStrategy, validateConfig, validateStrategy };
+export { AGENT_VERSION, type AccountSummary, type AgentConfig, AgentConfigSchema, type AgentMode, AgentRuntime, type AgentStatusPayload, AnthropicAdapter, BaseLLMAdapter, type BridgeResult, type BridgeStep, type CommandType, DeepSeekAdapter, FileStore, type FillCallback, type FundingCallback, type FundingPayment, GoogleAdapter, GroqAdapter, HYPERLIQUID_DOMAIN, HyperliquidClient, HyperliquidSigner, HyperliquidWebSocket, type LLMAdapter, type LLMConfig, LLMConfigSchema, type LLMMessage, type LLMMetadata, type LLMProvider, LLMProviderSchema, type LLMResponse, type LiquidationCallback, type LocalPosition, MARKET_CATEGORIES, MarketBrowser, type MarketCategory, type MarketData, MarketDataService, type MessageLevel, type MessageType, MistralAdapter, OllamaAdapter, type OnboardingStatus, OpenAIAdapter, OrderManager, type OrderResult, type PerpAction, type PerpConfig$1 as PerpConfig, PerpConfigSchema, type PerpFill, type PerpMarketData, PerpOnboarding, type PerpPosition, type PerpStrategyFunction, PerpTradeRecorder, type PerpTradeSignal, type PerpConfig as PerpTradingConfig, PolymarketClient, PositionManager, type PositionSummary, PositionTracker, type PredictionAccountSummary, type PredictionAction, type PredictionConfig$1 as PredictionConfig, PredictionConfigSchema, type PredictionFill, PredictionFunding, type PredictionFundingConfig, type PredictionMarket, PredictionOrderManager, type PredictionPosition, PredictionPositionManager, type PredictionStrategyFunction, PredictionTradeRecorder, type PredictionTradeSignal, type PredictionConfig as PredictionTradingConfig, type RecordPerpTradeParams, type RecordPredictionTradeParams, RelayClient, type RelayCommand, type RelayConfig$1 as RelayConfig, RelayConfigSchema, RiskManager, type RiskState, type RiskUniverse, RiskUniverseSchema, type RuntimeConfig, STRATEGY_TEMPLATES, type StrategyContext, type StrategyFunction, type StrategyStore, type StrategyTemplate, TogetherAdapter, type TrackedPosition, TradeExecutor, type TradeRecord, type TradeSignal, type TradingConfig, TradingConfigSchema, type VaultConfig, VaultConfigSchema, VaultManager, type VaultManagerConfig, type VaultPolicy, VaultPolicySchema, type VaultStatus, calculatePredictionFee, createLLMAdapter, createSampleConfig, decodePredictionInstrument, decryptEnvFile, encodePredictionInstrument, encryptEnvFile, fillHashToBytes32, fillOidToBytes32, getAllStrategyTemplates, getNextNonce, getStrategyTemplate, loadConfig, loadSecureEnv, loadStrategy, orderIdToBytes32, tradeIdToBytes32, validateConfig, validateStrategy };