openbroker 1.1.1 → 1.2.0

package/README.md

@@ -106,36 +106,38 @@ openbroker markets --sort change --top 10  # Top movers
 
 #### `all-markets` — All Markets
 
-Browse all available markets across main perps, HIP-3 perps, and spot — grouped by type.
+Browse all available markets across main perps, HIP-3 perps, spot, and HIP-4 outcomes — grouped by type.
 
 ```bash
 openbroker all-markets                # Everything
 openbroker all-markets --type perp    # Main perps only
 openbroker all-markets --type hip3    # HIP-3 perps only
 openbroker all-markets --type spot    # Spot only
+openbroker all-markets --type outcome # HIP-4 outcomes only
 openbroker all-markets --top 20       # Top 20 by volume
 ```
 
 | Flag | Description | Default |
 |------|-------------|---------|
-| `--type` | Filter: `perp`, `spot`, `hip3`, or `all` | `all` |
+| `--type` | Filter: `perp`, `spot`, `hip3`, `outcome`, or `all` | `all` |
 | `--top` | Limit to top N by volume | — |
 | `--verbose` | Show detailed output | — |
 
 #### `search` — Search Markets
 
-Search for assets by name across all providers (perps, HIP-3, spot). Shows funding comparison when an asset is listed on multiple venues.
+Search for assets by name across all providers (perps, HIP-3, spot, HIP-4 outcomes). Shows funding comparison when an asset is listed on multiple venues.
 
 ```bash
 openbroker search --query GOLD             # Find all GOLD markets
 openbroker search --query ETH --type perp  # ETH perps only
 openbroker search --query PURR --type spot # PURR spot only
+openbroker search --query BTC --type outcome # HIP-4 outcomes only
 ```
 
 | Flag | Description | Default |
 |------|-------------|---------|
 | `--query` | Search term (matches coin name) | **required** |
-| `--type` | Filter: `perp`, `spot`, `hip3`, or `all` | `all` |
+| `--type` | Filter: `perp`, `spot`, `hip3`, `outcome`, or `all` | `all` |
 | `--verbose` | Show detailed output | — |
 
 #### `spot` — Spot Markets & Balances
@@ -154,6 +156,26 @@ openbroker spot --top 20         # Top 20 by volume
 | `--top` | Limit to top N by volume | — |
 | `--verbose` | Show token metadata | — |
 
+#### `outcomes` — HIP-4 Outcome Markets
+
+Search and inspect prediction/outcome markets. Outcome sides use Hyperliquid's encoded spot-like coin form: `#<encoding>`, where `encoding = 10 * outcomeId + side`; side `0` is usually YES and side `1` is usually NO.
+
+```bash
+openbroker outcomes --query BTC
+openbroker outcomes --outcome 123
+openbroker outcomes --outcome 123 --side yes --json
+openbroker outcomes --balances
+```
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--query` | Search market name, description, underlying, expiry, or target price | — |
+| `--outcome` | Outcome id, `#<encoding>`, or `+<encoding>` | — |
+| `--side` | Outcome side for plain ids: `yes`, `no`, `0`, or `1` | `yes` |
+| `--balances` | Show outcome token balances | — |
+| `--top` | Limit to top N matches | — |
+| `--json` | Machine-readable output | — |
+
 #### `fills` — Trade Fill History
 
 View your trade executions with prices, fees, and realized PnL.
@@ -379,6 +401,30 @@ openbroker cancel --all --dry              # Preview what would be cancelled
 | `--all` | Cancel all open orders | — |
 | `--dry` | Show orders without cancelling | — |
 
+#### `outcome-buy` / `outcome-sell` / `outcome-order` — HIP-4 Outcome Orders
+
+Buy or sell a YES/NO outcome token. Buying opens exposure to that side; selling reduces or closes that token balance. Market orders are IOC limits with slippage protection.
+
+```bash
+openbroker outcomes --query BTC
+openbroker outcome-buy --outcome 123 --outcome-side yes --size 10 --dry
+openbroker outcome-buy --outcome 123 --outcome-side no --size 5 --price 0.42
+openbroker outcome-sell --outcome #1230 --size 10
+openbroker outcome-order --outcome 123 --outcome-side yes --side buy --size 10
+```
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--outcome` | Outcome id, `#<encoding>`, or `+<encoding>` | **required** |
+| `--outcome-side` | `yes`, `no`, `0`, or `1` when using a plain outcome id | `yes` |
+| `--side` | `buy` or `sell` (auto-set by shortcuts) | **required** |
+| `--size` | Size in outcome token units | **required** |
+| `--price` | Limit price between 0 and 1 (omit for market IOC) | market |
+| `--tif` | Time in force for limit orders: `Gtc`, `Ioc`, `Alo` | `Gtc` |
+| `--slippage` | Slippage tolerance in bps for market orders | `50` |
+| `--sz-decimals` | Override size decimals if metadata omits token decimals | metadata / `0` |
+| `--dry` | Preview without executing | — |
+
 ---
 
 ### Advanced Execution
@@ -742,8 +788,9 @@ When loaded, the plugin registers these agent tools:
 | Info | `ob_candles` | OHLCV candle data for an asset |
 | Info | `ob_trades` | Recent trades (tape) for an asset |
 | Info | `ob_markets` | Market data (price, volume, OI) |
-| Info | `ob_search` | Search assets across perps, HIP-3, and spot |
+| Info | `ob_search` | Search assets across perps, HIP-3, spot, and HIP-4 outcomes |
 | Info | `ob_spot` | Spot markets and token balances |
+| Info | `ob_outcomes` | HIP-4 outcome markets and outcome token balances |
 | Info | `ob_rate_limit` | API rate limit usage and capacity |
 | Trading | `ob_buy` | Market buy |
 | Trading | `ob_sell` | Market sell |
@@ -751,6 +798,8 @@ When loaded, the plugin registers these agent tools:
 | Trading | `ob_trigger` | Trigger order (TP/SL) |
 | Trading | `ob_tpsl` | Set TP/SL on existing position |
 | Trading | `ob_cancel` | Cancel orders |
+| Trading | `ob_outcome_buy` | Buy a HIP-4 YES/NO outcome token |
+| Trading | `ob_outcome_sell` | Sell or close a HIP-4 YES/NO outcome token |
 | Advanced | `ob_twap` | Native TWAP order (exchange-managed) |
 | Advanced | `ob_twap_cancel` | Cancel a running TWAP order |
 | Advanced | `ob_twap_status` | View TWAP order history/status |

package/bin/cli.ts

@@ -20,7 +20,7 @@ const commands: Record<string, { script: string; description: string }> = {
   'positions': { script: 'info/positions.ts', description: 'View open positions' },
   'funding': { script: 'info/funding.ts', description: 'View funding rates' },
   'markets': { script: 'info/markets.ts', description: 'View market data' },
-  'all-markets': { script: 'info/all-markets.ts', description: 'View all markets (perps, HIP-3, spot)' },
+  'all-markets': { script: 'info/all-markets.ts', description: 'View all markets (perps, HIP-3, spot, HIP-4)' },
   'search': { script: 'info/search-markets.ts', description: 'Search for assets across providers' },
   'spot': { script: 'info/spot.ts', description: 'View spot markets and balances' },
   'fills': { script: 'info/fills.ts', description: 'View trade fill history' },
@@ -32,6 +32,7 @@ const commands: Record<string, { script: string; description: string }> = {
   'trades': { script: 'info/trades.ts', description: 'View recent trades for an asset' },
   'rate-limit': { script: 'info/rate-limit.ts', description: 'View API rate limit status' },
   'funding-scan': { script: 'info/funding-scan.ts', description: 'Scan funding rates across all dexes' },
+  'outcomes': { script: 'info/outcomes.ts', description: 'Search and inspect HIP-4 outcome markets' },
 
   // Operations
   'buy': { script: 'operations/market-order.ts', description: 'Market buy order' },
@@ -50,6 +51,11 @@ const commands: Record<string, { script: string; description: string }> = {
   'spot-buy': { script: 'operations/spot-order.ts', description: 'Spot buy order' },
   'spot-sell': { script: 'operations/spot-order.ts', description: 'Spot sell order' },
   'spot-order': { script: 'operations/spot-order.ts', description: 'Spot order (market or limit)' },
+  'outcome-buy': { script: 'operations/outcome-order.ts', description: 'Buy a HIP-4 outcome token' },
+  'outcome-sell': { script: 'operations/outcome-order.ts', description: 'Sell a HIP-4 outcome token' },
+  'outcome-open': { script: 'operations/outcome-order.ts', description: 'Open a HIP-4 outcome position' },
+  'outcome-close': { script: 'operations/outcome-order.ts', description: 'Close a HIP-4 outcome position' },
+  'outcome-order': { script: 'operations/outcome-order.ts', description: 'HIP-4 outcome order (market or limit)' },
 
   // Automations
   'auto': { script: 'auto/cli.ts', description: 'Run/manage trading automations' },
@@ -76,11 +82,12 @@ Info Commands:
   candles              View OHLCV candle data
   trades               View recent trades (tape) for an asset
   markets              View market data for main perps
-  all-markets          View all markets (perps, HIP-3, spot)
+  all-markets          View all markets (perps, HIP-3, spot, HIP-4)
   search               Search for assets across all providers
   spot                 View spot markets and balances
   rate-limit           View API rate limit status
   funding-scan         Scan funding rates across all dexes (main + HIP-3)
+  outcomes             Search and inspect HIP-4 outcome markets
 
 Trading Commands:
   buy                  Market buy order
@@ -96,6 +103,13 @@ Spot Trading:
   spot-sell            Spot sell order
   spot-order           Spot order (market or limit, specify --side)
 
+HIP-4 Outcome Trading:
+  outcome-buy          Buy a YES/NO outcome token
+  outcome-sell         Sell a YES/NO outcome token
+  outcome-open         Alias for outcome-buy
+  outcome-close        Alias for outcome-sell
+  outcome-order        Outcome order (market or limit, specify --side)
+
 Advanced Execution:
   twap                 Native TWAP order (exchange-managed)
   twap-cancel          Cancel a running TWAP order
@@ -127,6 +141,8 @@ Examples:
   openbroker buy --coin ETH --size 0.1          # Market buy 0.1 ETH
   openbroker limit --coin BTC --side buy --size 0.01 --price 60000
   openbroker search --query GOLD                # Find GOLD across providers
+  openbroker outcomes --query BTC               # Find HIP-4 outcome markets
+  openbroker outcome-buy --outcome 123 --outcome-side yes --size 10 --dry
   openbroker tpsl --coin HYPE --tp 40 --sl 30   # Set TP/SL on position
 
 Documentation: https://github.com/aurracloud/open-broker
@@ -204,6 +220,14 @@ function main() {
     runScript(commands['spot-order'].script, ['--side', 'sell', ...commandArgs]);
     return;
   }
+  if (command === 'outcome-buy' || command === 'outcome-open') {
+    runScript(commands['outcome-order'].script, ['--side', 'buy', ...commandArgs]);
+    return;
+  }
+  if (command === 'outcome-sell' || command === 'outcome-close') {
+    runScript(commands['outcome-order'].script, ['--side', 'sell', ...commandArgs]);
+    return;
+  }
 
   // Handle version
   if (command === '--version' || command === '-v') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbroker",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Hyperliquid trading CLI - execute orders, manage positions, and run trading strategies",
   "type": "module",
   "bin": {
@@ -30,6 +30,7 @@
     "search-markets": "tsx scripts/info/search-markets.ts",
     "spot": "tsx scripts/info/spot.ts",
     "market-order": "tsx scripts/operations/market-order.ts",
+    "outcome-order": "tsx scripts/operations/outcome-order.ts",
     "limit-order": "tsx scripts/operations/limit-order.ts",
     "trigger-order": "tsx scripts/operations/trigger-order.ts",
     "set-tpsl": "tsx scripts/operations/set-tpsl.ts",
@@ -41,6 +42,7 @@
     "bracket": "tsx scripts/operations/bracket.ts",
     "chase": "tsx scripts/operations/chase.ts",
     "funding-scan": "tsx scripts/info/funding-scan.ts",
+    "outcomes": "tsx scripts/info/outcomes.ts",
     "prepublishOnly": "npm run test:cli",
     "test:cli": "node --import tsx bin/cli.ts --help"
   },

package/scripts/auto/runtime.ts

@@ -53,12 +53,21 @@ async function loadConventionObservers(log: AutomationLogger): Promise<Automatio
       const observer = typeof exported === 'function' ? exported() : exported;
       if (observer && typeof observer === 'object') {
         observers.push(observer as AutomationAuditObserver);
-        log.debug(`Loaded audit observer: ${name}`);
+        log.info(`[audit-observer] loaded: ${name}`);
+      } else {
+        // Package resolved but its factory returned null/undefined — typically
+        // because required env (e.g. OB_DASHBOARD_URL) is missing. Surface this
+        // so operators don't silently lose telemetry.
+        log.warn(
+          `[audit-observer] ${name} resolved but factory returned no observer — check the package's required env vars`
+        );
       }
     } catch (err) {
       const code = (err as NodeJS.ErrnoException | undefined)?.code;
-      if (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND') {
-        log.warn(`Failed to load audit observer "${name}": ${err instanceof Error ? err.message : String(err)}`);
+      if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') {
+        log.info(`[audit-observer] ${name} not installed — skipping (install it alongside openbroker to forward telemetry)`);
+      } else {
+        log.warn(`[audit-observer] failed to load "${name}": ${err instanceof Error ? err.message : String(err)}`);
       }
     }
   }

package/scripts/core/client.ts

@@ -13,6 +13,9 @@ import type {
   AssetCtx,
   ClearinghouseState,
   OpenOrder,
+  OutcomeMetaResponse,
+  OutcomeMarket,
+  OutcomeQuestion,
 } from './types.js';
 import { loadConfig, isMainnet } from './config.js';
 import { roundPrice, roundSize } from './utils.js';
@@ -51,6 +54,8 @@ export class HyperliquidClient {
   private spotSzDecimalsMap: Map<string, number> = new Map();
   /** Whether spot metadata has been loaded */
   private spotMetaLoaded: boolean = false;
+  /** HIP-4 outcome metadata cache */
+  private outcomeMeta: OutcomeMetaResponse | null = null;
   public verbose: boolean = false;
 
   constructor(config?: OpenBrokerConfig) {
@@ -658,6 +663,247 @@ export class HyperliquidClient {
     };
   }
 
+  // ============ HIP-4 Outcomes ============
+
+  private parseOutcomeDescription(description: string): Record<string, string> {
+    const parsed: Record<string, string> = {};
+    for (const part of description.split('|')) {
+      const idx = part.indexOf(':');
+      if (idx <= 0) continue;
+      parsed[part.slice(0, idx)] = part.slice(idx + 1);
+    }
+    return parsed;
+  }
+
+  private normalizeOutcomeSide(side: string | number): 0 | 1 {
+    if (typeof side === 'number') {
+      if (side === 0 || side === 1) return side;
+    } else {
+      const normalized = side.trim().toLowerCase();
+      if (normalized === '0' || normalized === 'yes' || normalized === 'y') return 0;
+      if (normalized === '1' || normalized === 'no' || normalized === 'n') return 1;
+    }
+    throw new Error(`Invalid outcome side "${side}". Use yes/no or 0/1.`);
+  }
+
+  getOutcomeEncoding(outcome: number, side: 0 | 1): number {
+    return 10 * outcome + side;
+  }
+
+  getOutcomeCoin(outcome: number, side: 0 | 1): string {
+    return `#${this.getOutcomeEncoding(outcome, side)}`;
+  }
+
+  getOutcomeAssetId(outcome: number, side: 0 | 1): number {
+    return 100_000_000 + this.getOutcomeEncoding(outcome, side);
+  }
+
+  resolveOutcomeRef(ref: string | number, side?: string | number): {
+    outcome: number;
+    side: 0 | 1;
+    encoding: number;
+    coin: string;
+    tokenName: string;
+    assetId: number;
+  } {
+    if (typeof ref === 'number') {
+      const resolvedSide = this.normalizeOutcomeSide(side ?? 0);
+      const encoding = this.getOutcomeEncoding(ref, resolvedSide);
+      return {
+        outcome: ref,
+        side: resolvedSide,
+        encoding,
+        coin: `#${encoding}`,
+        tokenName: `+${encoding}`,
+        assetId: 100_000_000 + encoding,
+      };
+    }
+
+    const trimmed = ref.trim();
+    const encoded = trimmed.startsWith('#') || trimmed.startsWith('+')
+      ? parseInt(trimmed.slice(1), 10)
+      : NaN;
+
+    if (!Number.isNaN(encoded)) {
+      const resolvedSide = encoded % 10;
+      if (resolvedSide !== 0 && resolvedSide !== 1) {
+        throw new Error(`Invalid outcome encoding "${ref}". Outcome side must encode to 0 or 1.`);
+      }
+      const outcome = Math.floor(encoded / 10);
+      return {
+        outcome,
+        side: resolvedSide as 0 | 1,
+        encoding: encoded,
+        coin: `#${encoded}`,
+        tokenName: `+${encoded}`,
+        assetId: 100_000_000 + encoded,
+      };
+    }
+
+    const outcome = parseInt(trimmed, 10);
+    if (!Number.isFinite(outcome) || outcome < 0) {
+      throw new Error(`Invalid outcome reference "${ref}". Use an outcome id, #<encoding>, or +<encoding>.`);
+    }
+
+    const resolvedSide = this.normalizeOutcomeSide(side ?? 0);
+    const encoding = this.getOutcomeEncoding(outcome, resolvedSide);
+    return {
+      outcome,
+      side: resolvedSide,
+      encoding,
+      coin: `#${encoding}`,
+      tokenName: `+${encoding}`,
+      assetId: 100_000_000 + encoding,
+    };
+  }
+
+  async getOutcomeMeta(): Promise<OutcomeMetaResponse> {
+    if (this.outcomeMeta) return this.outcomeMeta;
+
+    this.log('Fetching outcomeMeta...');
+    const data = await this.postInfo<OutcomeMetaResponse>({ type: 'outcomeMeta' }, 'outcomeMeta');
+    if (!data || !Array.isArray(data.outcomes)) {
+      throw new Error('outcomeMeta returned empty/malformed payload.');
+    }
+    this.outcomeMeta = {
+      outcomes: data.outcomes,
+      questions: data.questions ?? [],
+    };
+    this.log(`Loaded ${this.outcomeMeta.outcomes.length} outcome markets`);
+    return this.outcomeMeta;
+  }
+
+  private async getOutcomeCtxMap(): Promise<Map<string, {
+    coin?: string;
+    dayNtlVlm?: string;
+    markPx?: string;
+    midPx?: string | null;
+    prevDayPx?: string;
+  }>> {
+    const ctxMap = new Map<string, {
+      coin?: string;
+      dayNtlVlm?: string;
+      markPx?: string;
+      midPx?: string | null;
+      prevDayPx?: string;
+    }>();
+
+    try {
+      const spotData = await this.getSpotMetaAndAssetCtxs();
+      for (const ctx of spotData.assetCtxs) {
+        if (ctx.coin) ctxMap.set(ctx.coin, ctx);
+      }
+    } catch (e) {
+      this.log('Unable to load spot/outcome contexts:', e);
+    }
+
+    try {
+      const mids = await this.getAllMids();
+      for (const [coin, midPx] of Object.entries(mids)) {
+        if (!coin.startsWith('#')) continue;
+        const existing = ctxMap.get(coin) ?? { coin };
+        existing.midPx = existing.midPx ?? midPx;
+        existing.markPx = existing.markPx ?? midPx;
+        ctxMap.set(coin, existing);
+      }
+    } catch (e) {
+      this.log('Unable to load allMids for outcomes:', e);
+    }
+
+    return ctxMap;
+  }
+
+  async getOutcomeMarkets(): Promise<OutcomeMarket[]> {
+    const [meta, spotMeta, ctxMap] = await Promise.all([
+      this.getOutcomeMeta(),
+      this.getSpotMeta().catch(() => null),
+      this.getOutcomeCtxMap(),
+    ]);
+
+    const tokenDecimals = new Map<number, number>();
+    if (spotMeta) {
+      for (const token of spotMeta.tokens) {
+        tokenDecimals.set(token.index, token.szDecimals);
+      }
+    }
+
+    const questions = new Map<number, OutcomeQuestion>();
+    for (const question of meta.questions ?? []) {
+      for (const outcome of question.namedOutcomes) {
+        questions.set(outcome, question);
+      }
+      questions.set(question.fallbackOutcome, question);
+    }
+
+    return meta.outcomes.map((outcome) => {
+      const sides = outcome.sideSpecs.map((sideSpec, idx) => {
+        const side = idx as 0 | 1;
+        const encoding = this.getOutcomeEncoding(outcome.outcome, side);
+        const coin = `#${encoding}`;
+        const ctx = ctxMap.get(coin);
+        return {
+          side,
+          name: sideSpec.name,
+          encoding,
+          coin,
+          tokenName: `+${encoding}`,
+          assetId: 100_000_000 + encoding,
+          token: sideSpec.token,
+          szDecimals: sideSpec.token !== undefined ? tokenDecimals.get(sideSpec.token) : undefined,
+          midPx: ctx?.midPx ?? undefined,
+          markPx: ctx?.markPx,
+          prevDayPx: ctx?.prevDayPx,
+          dayNtlVlm: ctx?.dayNtlVlm,
+        };
+      });
+
+      return {
+        outcome: outcome.outcome,
+        name: outcome.name,
+        description: outcome.description,
+        parsedDescription: this.parseOutcomeDescription(outcome.description),
+        sides,
+        question: questions.get(outcome.outcome),
+      };
+    });
+  }
+
+  async getOutcomeMarket(outcomeId: number): Promise<OutcomeMarket | null> {
+    const markets = await this.getOutcomeMarkets();
+    return markets.find((market) => market.outcome === outcomeId) ?? null;
+  }
+
+  async getOutcomeSzDecimals(outcome: number, side: 0 | 1): Promise<number> {
+    const market = await this.getOutcomeMarket(outcome);
+    return market?.sides.find((s) => s.side === side)?.szDecimals ?? 0;
+  }
+
+  async getOutcomeMidPrice(outcome: number, side: 0 | 1): Promise<number> {
+    const coin = this.getOutcomeCoin(outcome, side);
+    const markets = await this.getOutcomeMarkets();
+    const marketSide = markets
+      .find((market) => market.outcome === outcome)
+      ?.sides.find((s) => s.side === side);
+    const fromMeta = marketSide?.midPx ?? marketSide?.markPx;
+    if (fromMeta) {
+      const mid = parseFloat(fromMeta);
+      if (mid > 0) return mid;
+    }
+
+    const mids = await this.getAllMids();
+    const mid = parseFloat(mids[coin] || '0');
+    if (mid > 0) return mid;
+
+    try {
+      const book = await this.getL2Book(coin);
+      if (book.midPrice > 0) return book.midPrice;
+    } catch (e) {
+      this.log(`Unable to fetch outcome L2 book for ${coin}:`, e);
+    }
+
+    throw new Error(`No outcome price for ${coin}. The market may not be open or may have no liquidity.`);
+  }
+
   /**
    * Load spot metadata into lookup maps.
    * Spot asset index for orders = 10000 + universe[i].index
@@ -2346,6 +2592,118 @@ export class HyperliquidClient {
     );
   }
 
+  /**
+   * Place a HIP-4 outcome order.
+   * Outcome assets are spot-like, but encoded as:
+   *   encoding = 10 * outcome + side
+   *   assetId = 100_000_000 + encoding
+   *   coin = #<encoding>
+   *
+   * Side 0 is usually YES and side 1 is usually NO, per outcomeMeta.sideSpecs.
+   */
+  async outcomeOrder(
+    outcomeRef: string | number,
+    outcomeSide: string | number | undefined,
+    isBuy: boolean,
+    size: number,
+    price: number,
+    orderType: { limit: { tif: 'Gtc' | 'Ioc' | 'Alo' } },
+    includeBuilder: boolean = true,
+    szDecimalsOverride?: number,
+  ): Promise<OrderResponse> {
+    await this.requireTrading();
+
+    const resolved = this.resolveOutcomeRef(outcomeRef, outcomeSide);
+    const szDecimals = szDecimalsOverride ?? await this.getOutcomeSzDecimals(resolved.outcome, resolved.side);
+
+    const orderWire = {
+      a: resolved.assetId,
+      b: isBuy,
+      p: roundPrice(price, szDecimals, true),
+      s: roundSize(size, szDecimals),
+      r: false,
+      t: orderType,
+    };
+
+    this.log('Placing outcome order:', JSON.stringify({ resolved, orderWire }, null, 2));
+
+    const orderRequest: {
+      orders: typeof orderWire[];
+      grouping: 'na';
+      builder?: BuilderInfo;
+    } = {
+      orders: [orderWire],
+      grouping: 'na',
+    };
+
+    if (includeBuilder && !this.isTestnet && this.config.builderAddress !== '0x0000000000000000000000000000000000000000') {
+      orderRequest.builder = this.builderInfo;
+      this.log('Including builder fee:', this.builderInfo);
+    }
+
+    try {
+      const response = await this.exchange.order(orderRequest, this.vaultParam);
+      this.log('Outcome order response:', JSON.stringify(response, null, 2));
+      return response as unknown as OrderResponse;
+    } catch (error) {
+      this.log('Outcome order error:', error);
+      return {
+        status: 'err',
+        response: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  async outcomeMarketOrder(
+    outcomeRef: string | number,
+    outcomeSide: string | number | undefined,
+    isBuy: boolean,
+    size: number,
+    slippageBps?: number,
+    szDecimalsOverride?: number,
+  ): Promise<OrderResponse> {
+    const resolved = this.resolveOutcomeRef(outcomeRef, outcomeSide);
+    const midPrice = await this.getOutcomeMidPrice(resolved.outcome, resolved.side);
+    const slippage = (slippageBps ?? this.config.slippageBps) / 10000;
+    const limitPrice = isBuy
+      ? midPrice * (1 + slippage)
+      : midPrice * (1 - slippage);
+
+    this.log(`Outcome market order: ${resolved.coin} ${isBuy ? 'BUY' : 'SELL'} ${size} @ ${limitPrice} (mid: ${midPrice})`);
+
+    return this.outcomeOrder(
+      outcomeRef,
+      outcomeSide,
+      isBuy,
+      size,
+      limitPrice,
+      { limit: { tif: 'Ioc' } },
+      true,
+      szDecimalsOverride,
+    );
+  }
+
+  async outcomeLimitOrder(
+    outcomeRef: string | number,
+    outcomeSide: string | number | undefined,
+    isBuy: boolean,
+    size: number,
+    price: number,
+    tif: 'Gtc' | 'Ioc' | 'Alo' = 'Gtc',
+    szDecimalsOverride?: number,
+  ): Promise<OrderResponse> {
+    return this.outcomeOrder(
+      outcomeRef,
+      outcomeSide,
+      isBuy,
+      size,
+      price,
+      { limit: { tif } },
+      true,
+      szDecimalsOverride,
+    );
+  }
+
   /**
    * Cancel a spot order by coin and order ID.
    */

package/scripts/core/types.ts

@@ -119,6 +119,56 @@ export interface MetaAndAssetCtxs {
   assetCtxs: AssetCtx[];
 }
 
+// ============ Outcome / HIP-4 Types ============
+
+export interface OutcomeSideSpec {
+  name: string;
+  token?: number;
+}
+
+export interface OutcomeMetaEntry {
+  outcome: number;
+  name: string;
+  description: string;
+  sideSpecs: OutcomeSideSpec[];
+}
+
+export interface OutcomeQuestion {
+  question: number;
+  name: string;
+  description: string;
+  fallbackOutcome: number;
+  namedOutcomes: number[];
+  settledNamedOutcomes?: number[];
+}
+
+export interface OutcomeMetaResponse {
+  outcomes: OutcomeMetaEntry[];
+  questions?: OutcomeQuestion[];
+}
+
+export interface OutcomeMarket {
+  outcome: number;
+  name: string;
+  description: string;
+  parsedDescription: Record<string, string>;
+  sides: Array<{
+    side: 0 | 1;
+    name: string;
+    encoding: number;
+    coin: string;
+    tokenName: string;
+    assetId: number;
+    token?: number;
+    szDecimals?: number;
+    midPx?: string;
+    markPx?: string;
+    prevDayPx?: string;
+    dayNtlVlm?: string;
+  }>;
+  question?: OutcomeQuestion;
+}
+
 // ============ Account Types ============
 
 export interface Position {

package/scripts/info/all-markets.ts

@@ -4,7 +4,7 @@
 import { getClient } from '../core/client.js';
 
 interface Args {
-  type?: 'perp' | 'spot' | 'hip3' | 'all';
+  type?: 'perp' | 'spot' | 'hip3' | 'outcome' | 'all';
   top?: number;
   verbose?: boolean;
   json?: boolean;
@@ -17,7 +17,7 @@ function parseArgs(): Args {
     const arg = process.argv[i];
     if (arg === '--type' && process.argv[i + 1]) {
       const val = process.argv[++i].toLowerCase();
-      if (['perp', 'spot', 'hip3', 'all'].includes(val)) {
+      if (['perp', 'spot', 'hip3', 'outcome', 'all'].includes(val)) {
         args.type = val as Args['type'];
       }
     } else if (arg === '--top' && process.argv[i + 1]) {
@@ -33,7 +33,7 @@ All Markets - View all available markets on Hyperliquid
 Usage: npx tsx scripts/info/all-markets.ts [options]
 
 Options:
-  --type <type>    Market type: perp, spot, hip3, or all (default: all)
+  --type <type>    Market type: perp, spot, hip3, outcome, or all (default: all)
   --top <n>        Show only top N markets by volume
   --json           Output as JSON (machine-readable)
   --verbose        Show detailed output
@@ -44,6 +44,7 @@ Examples:
   npx tsx scripts/info/all-markets.ts --type perp    # Show only main perps
   npx tsx scripts/info/all-markets.ts --type hip3    # Show only HIP-3 perps
   npx tsx scripts/info/all-markets.ts --type spot    # Show only spot markets
+  npx tsx scripts/info/all-markets.ts --type outcome # Show only HIP-4 outcomes
   npx tsx scripts/info/all-markets.ts --top 20       # Show top 20 by volume
   npx tsx scripts/info/all-markets.ts --json         # JSON output
 `);
@@ -77,7 +78,7 @@ function formatFunding(rate: string): string {
 }
 
 interface MarketRow {
-  type: 'perp' | 'spot' | 'hip3';
+  type: 'perp' | 'spot' | 'hip3' | 'outcome';
   provider: string;
   coin: string;
   assetId: number;
@@ -85,6 +86,9 @@ interface MarketRow {
   volume24h: number;
   funding?: string;
   maxLeverage?: number;
+  outcome?: number;
+  outcomeSide?: string;
+  description?: string;
 }
 
 async function main() {
@@ -183,6 +187,30 @@ async function main() {
     }
   }
 
+  // Fetch HIP-4 outcomes
+  if (args.type === 'all' || args.type === 'outcome') {
+    try {
+      const outcomes = await client.getOutcomeMarkets();
+      for (const market of outcomes) {
+        for (const side of market.sides) {
+          allMarkets.push({
+            type: 'outcome',
+            provider: 'HIP-4',
+            coin: side.coin,
+            assetId: side.assetId,
+            price: side.midPx ?? side.markPx ?? '0',
+            volume24h: parseFloat(side.dayNtlVlm || '0'),
+            outcome: market.outcome,
+            outcomeSide: side.name,
+            description: market.description,
+          });
+        }
+      }
+    } catch (e) {
+      if (args.verbose) console.error('Failed to fetch HIP-4 outcomes:', e);
+    }
+  }
+
   // Sort by volume
   allMarkets.sort((a, b) => b.volume24h - a.volume24h);
 
@@ -198,6 +226,7 @@ async function main() {
   const perps = markets.filter((m) => m.type === 'perp');
   const hip3 = markets.filter((m) => m.type === 'hip3');
   const spots = markets.filter((m) => m.type === 'spot');
+  const outcomes = markets.filter((m) => m.type === 'outcome');
 
   // Print summary
   console.log('=== Market Summary ===\n');
@@ -205,6 +234,7 @@ async function main() {
   console.log(`  - Main Perps: ${perps.length}`);
   console.log(`  - HIP-3 Perps: ${hip3.length}`);
   console.log(`  - Spot Markets: ${spots.length}`);
+  console.log(`  - HIP-4 Outcomes: ${outcomes.length}`);
   console.log();
 
   // Print perps
@@ -245,6 +275,19 @@ async function main() {
     }
     console.log();
   }
+
+  // Print HIP-4 outcome markets
+  if (outcomes.length > 0) {
+    console.log('=== HIP-4 Outcomes ===\n');
+    console.log('Coin           Outcome   Side      AssetID    Price       24h Volume');
+    console.log('-'.repeat(78));
+    for (const m of outcomes) {
+      console.log(
+        `${m.coin.padEnd(14)} ${String(m.outcome ?? '-').padStart(7)}   ${(m.outcomeSide ?? '-').padEnd(8)} ${String(m.assetId).padStart(9)}    ${formatPrice(m.price).padStart(7)} ${formatVolume(m.volume24h).padStart(13)}`
+      );
+    }
+    console.log();
+  }
 }
 
 main().catch((e) => {

package/scripts/info/outcomes.ts

@@ -0,0 +1,200 @@
+#!/usr/bin/env tsx
+// HIP-4 Outcomes - search and inspect prediction markets
+
+import { getClient } from '../core/client.js';
+
+interface Args {
+  query?: string;
+  outcome?: string;
+  side?: string;
+  balances?: boolean;
+  top?: number;
+  verbose?: boolean;
+  json?: boolean;
+}
+
+function parseArgs(): Args {
+  const args: Args = {};
+
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if ((arg === '--query' || arg === '-q') && process.argv[i + 1]) {
+      args.query = process.argv[++i];
+    } else if ((arg === '--outcome' || arg === '--id') && process.argv[i + 1]) {
+      args.outcome = process.argv[++i];
+    } else if (arg === '--side' && process.argv[i + 1]) {
+      args.side = process.argv[++i];
+    } else if (arg === '--balances') {
+      args.balances = true;
+    } else if (arg === '--top' && process.argv[i + 1]) {
+      args.top = parseInt(process.argv[++i], 10);
+    } else if (arg === '--verbose') {
+      args.verbose = true;
+    } else if (arg === '--json') {
+      args.json = true;
+    } else if (arg === '--help' || arg === '-h') {
+      printUsage();
+      process.exit(0);
+    } else if (!args.query && !arg.startsWith('-')) {
+      args.query = arg;
+    }
+  }
+
+  return args;
+}
+
+function printUsage() {
+  console.log(`
+Open Broker - HIP-4 Outcomes
+============================
+
+Search and inspect Hyperliquid outcome markets.
+
+Usage:
+  openbroker outcomes [--query <text>] [--outcome <id|#encoding|+encoding>] [options]
+
+Options:
+  --query, -q <text>       Search market name, description, underlying, expiry, target
+  --outcome, --id <ref>    Show one outcome by id or encoded coin (#1230 / +1230)
+  --side <yes|no|0|1>      Select a side when using a plain outcome id
+  --balances               Show outcome token balances for the configured account
+  --top <n>                Show only top N matches
+  --json                   Output as JSON
+  --verbose                Include raw descriptions and question metadata
+
+Examples:
+  openbroker outcomes --query BTC
+  openbroker outcomes --outcome 123
+  openbroker outcomes --outcome 123 --side yes --json
+  openbroker outcomes --balances
+`);
+}
+
+function formatPrice(value?: string): string {
+  if (!value) return '-';
+  const n = parseFloat(value);
+  if (!Number.isFinite(n)) return value;
+  return n.toFixed(4);
+}
+
+function formatVolume(value?: string): string {
+  if (!value) return '-';
+  const n = parseFloat(value);
+  if (!Number.isFinite(n)) return value;
+  if (n >= 1_000_000) return `$${(n / 1_000_000).toFixed(2)}M`;
+  if (n >= 1_000) return `$${(n / 1_000).toFixed(2)}K`;
+  return `$${n.toFixed(2)}`;
+}
+
+async function main() {
+  const args = parseArgs();
+  const client = getClient();
+  client.verbose = args.verbose ?? false;
+
+  if (!args.json) {
+    console.log('Open Broker - HIP-4 Outcomes');
+    console.log('============================\n');
+  }
+
+  try {
+    if (args.balances) {
+      const balances = await client.getSpotBalances();
+      const outcomeBalances = (balances.balances ?? []).filter((b) =>
+        b.coin.startsWith('+') || b.coin.startsWith('#')
+      );
+
+      if (args.json) {
+        console.log(JSON.stringify(outcomeBalances, null, 2));
+        return;
+      }
+
+      if (outcomeBalances.length === 0) {
+        console.log('No outcome token balances found.');
+        return;
+      }
+
+      console.log('Outcome Balances');
+      console.log('----------------');
+      console.log('Token        Total              Hold               Entry Value');
+      console.log('-'.repeat(70));
+      for (const b of outcomeBalances) {
+        console.log(
+          `${b.coin.padEnd(12)} ${parseFloat(b.total).toFixed(6).padStart(18)} ` +
+          `${parseFloat(b.hold).toFixed(6).padStart(18)} ${formatVolume(b.entryNtl).padStart(15)}`
+        );
+      }
+      return;
+    }
+
+    let markets = await client.getOutcomeMarkets();
+
+    if (args.outcome) {
+      const resolved = client.resolveOutcomeRef(args.outcome, args.side);
+      markets = markets.filter((market) => market.outcome === resolved.outcome);
+      for (const market of markets) {
+        market.sides = market.sides.filter((side) => side.side === resolved.side);
+      }
+    }
+
+    if (args.query) {
+      const query = args.query.toUpperCase();
+      markets = markets.filter((market) => {
+        const parsed = Object.values(market.parsedDescription).join(' ');
+        const searchable = `${market.name} ${market.description} ${parsed}`.toUpperCase();
+        return searchable.includes(query);
+      });
+    }
+
+    markets.sort((a, b) => {
+      const aVol = Math.max(...a.sides.map((s) => parseFloat(s.dayNtlVlm ?? '0')));
+      const bVol = Math.max(...b.sides.map((s) => parseFloat(s.dayNtlVlm ?? '0')));
+      return bVol - aVol;
+    });
+
+    const displayMarkets = args.top ? markets.slice(0, args.top) : markets;
+
+    if (args.json) {
+      console.log(JSON.stringify(displayMarkets, null, 2));
+      return;
+    }
+
+    if (displayMarkets.length === 0) {
+      console.log('No outcome markets found.');
+      return;
+    }
+
+    console.log(`Found ${displayMarkets.length} outcome market(s)\n`);
+    console.log('Outcome   Side  Coin       AssetID      Price    24h Volume   Market');
+    console.log('-'.repeat(98));
+
+    for (const market of displayMarkets) {
+      const spec = market.parsedDescription;
+      const labelParts = [
+        spec.underlying,
+        spec.expiry ? `exp ${spec.expiry}` : undefined,
+        spec.targetPrice ? `target ${spec.targetPrice}` : undefined,
+      ].filter(Boolean);
+      const label = labelParts.length > 0 ? labelParts.join(' | ') : market.description;
+
+      for (const side of market.sides) {
+        console.log(
+          `${String(market.outcome).padStart(7)}   ${side.name.padEnd(4)}  ${side.coin.padEnd(9)} ` +
+          `${String(side.assetId).padStart(10)}   ${formatPrice(side.midPx ?? side.markPx).padStart(7)} ` +
+          `${formatVolume(side.dayNtlVlm).padStart(13)}   ${label}`
+        );
+      }
+
+      if (args.verbose) {
+        console.log(`          Description: ${market.description}`);
+        if (market.question) console.log(`          Question: ${market.question.name}`);
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    console.error('Note: Hyperliquid currently documents outcomeMeta as testnet-only.');
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/info/search-markets.ts

@@ -5,7 +5,7 @@ import { getClient } from '../core/client.js';
 
 interface Args {
   query: string;
-  type?: 'perp' | 'spot' | 'hip3' | 'all';
+  type?: 'perp' | 'spot' | 'hip3' | 'outcome' | 'all';
   verbose?: boolean;
   json?: boolean;
 }
@@ -19,7 +19,7 @@ function parseArgs(): Args {
       args.query = process.argv[++i];
     } else if (arg === '--type' && process.argv[i + 1]) {
       const val = process.argv[++i].toLowerCase();
-      if (['perp', 'spot', 'hip3', 'all'].includes(val)) {
+      if (['perp', 'spot', 'hip3', 'outcome', 'all'].includes(val)) {
         args.type = val as Args['type'];
       }
     } else if (arg === '--verbose') {
@@ -34,7 +34,7 @@ Usage: npx tsx scripts/info/search-markets.ts --query <search> [options]
 
 Options:
   --query <search>  Search term (required) - matches coin name
-  --type <type>     Filter by market type: perp, spot, hip3, or all (default: all)
+  --type <type>     Filter by market type: perp, spot, hip3, outcome, or all (default: all)
   --json            Output as JSON (machine-readable)
   --verbose         Show detailed output
   --help            Show this help
@@ -44,6 +44,7 @@ Examples:
   npx tsx scripts/info/search-markets.ts --query BTC        # Find all BTC markets
   npx tsx scripts/info/search-markets.ts --query ETH --type perp  # ETH perps only
   npx tsx scripts/info/search-markets.ts --query PURR --type spot # PURR spot only
+  npx tsx scripts/info/search-markets.ts --query BTC --type outcome # HIP-4 outcomes only
   npx tsx scripts/info/search-markets.ts --query HYPE --json      # JSON output
 `);
       process.exit(0);
@@ -95,7 +96,7 @@ async function main() {
   }
 
   interface Result {
-    type: 'perp' | 'spot' | 'hip3';
+    type: 'perp' | 'spot' | 'hip3' | 'outcome';
     provider: string;
     coin: string;
     assetId: number;
@@ -104,6 +105,9 @@ async function main() {
     funding?: string;
     maxLeverage?: number;
     openInterest?: string;
+    outcome?: number;
+    outcomeSide?: string;
+    description?: string;
   }
 
   const results: Result[] = [];
@@ -224,6 +228,34 @@ async function main() {
     }
   }
 
+  // Search HIP-4 outcome markets
+  if (args.type === 'all' || args.type === 'outcome') {
+    try {
+      const outcomes = await client.getOutcomeMarkets();
+      for (const market of outcomes) {
+        const parsed = Object.values(market.parsedDescription).join(' ');
+        const searchable = `${market.name} ${market.description} ${parsed}`.toUpperCase();
+        if (!searchable.includes(query)) continue;
+
+        for (const side of market.sides) {
+          results.push({
+            type: 'outcome',
+            provider: 'HIP-4',
+            coin: side.coin,
+            assetId: side.assetId,
+            price: side.midPx ?? side.markPx ?? '0',
+            volume24h: parseFloat(side.dayNtlVlm || '0'),
+            outcome: market.outcome,
+            outcomeSide: side.name,
+            description: market.description,
+          });
+        }
+      }
+    } catch (e) {
+      if (args.verbose) console.error('Failed to fetch HIP-4 outcomes:', e);
+    }
+  }
+
   // Sort by volume
   results.sort((a, b) => b.volume24h - a.volume24h);
 
@@ -242,11 +274,14 @@ async function main() {
   console.log('-'.repeat(112));
 
   for (const m of results) {
-    const typeStr = m.type === 'hip3' ? 'HIP-3' : m.type.charAt(0).toUpperCase() + m.type.slice(1);
+    const typeStr = m.type === 'hip3' ? 'HIP-3' : m.type === 'outcome' ? 'HIP-4' : m.type.charAt(0).toUpperCase() + m.type.slice(1);
     const oi = m.openInterest ? formatVolume(parseFloat(m.openInterest)) : '-';
     console.log(
       `${typeStr.padEnd(8)} ${m.provider.padEnd(16)} ${m.coin.padEnd(14)} ${String(m.assetId).padStart(7)}    ${formatPrice(m.price).padStart(16)} ${formatVolume(m.volume24h).padStart(13)} ${(m.funding ? formatFunding(m.funding) : '-').padStart(14)} ${oi.padStart(10)}`
     );
+    if (m.type === 'outcome' && args.verbose) {
+      console.log(`         Outcome ${m.outcome} ${m.outcomeSide}: ${m.description}`);
+    }
   }
 
   // Show comparison if same asset on multiple providers

package/scripts/operations/outcome-order.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env npx tsx
+// Execute a HIP-4 outcome order on Hyperliquid
+
+import { getClient } from '../core/client.js';
+import { checkBuilderFeeApproval, formatUsd, parseArgs } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - HIP-4 Outcome Order
+=================================
+
+Buy or sell a YES/NO outcome token.
+
+Usage:
+  openbroker outcome-order --outcome <id|#encoding|+encoding> --outcome-side <yes|no> --side <buy|sell> --size <SIZE>
+
+Options:
+  --outcome        Outcome id, outcome spot coin (#1230), or token name (+1230)
+  --outcome-side   Outcome side when --outcome is a plain id: yes/no or 0/1 (default: yes)
+  --side           Trade side: buy or sell
+  --size           Order size in outcome token units
+  --price          Limit price between 0.001 and 0.999 (omit for market IOC)
+  --tif            Time-in-force for limit orders: Gtc, Ioc, Alo (default: Gtc)
+  --slippage       Slippage tolerance in bps for market orders (default: config, usually 50)
+  --sz-decimals    Override size decimals if outcome metadata omits token decimals
+  --dry            Dry run - show order details without executing
+  --verbose        Show full API request/response for debugging
+
+Examples:
+  openbroker outcomes --query BTC
+  openbroker outcome-order --outcome 123 --outcome-side yes --side buy --size 10 --dry
+  openbroker outcome-buy --outcome 123 --outcome-side no --size 5 --price 0.42
+  openbroker outcome-sell --outcome #1230 --size 10
+`);
+}
+
+function formatOutcomePrice(price: number): string {
+  return price.toFixed(4);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help || args.h) {
+    printUsage();
+    process.exit(0);
+  }
+
+  const outcomeRef = args.outcome as string;
+  const outcomeSide = args['outcome-side'] as string | undefined;
+  const side = args.side as string;
+  const size = parseFloat(args.size as string);
+  const price = args.price ? parseFloat(args.price as string) : undefined;
+  const tif = (args.tif as 'Gtc' | 'Ioc' | 'Alo') ?? 'Gtc';
+  const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
+  const szDecimals = args['sz-decimals'] ? parseInt(args['sz-decimals'] as string, 10) : undefined;
+  const dryRun = args.dry as boolean;
+
+  if (!outcomeRef || !side || isNaN(size)) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (side !== 'buy' && side !== 'sell') {
+    console.error('Error: --side must be "buy" or "sell"');
+    process.exit(1);
+  }
+
+  if (size <= 0) {
+    console.error('Error: --size must be positive');
+    process.exit(1);
+  }
+
+  if (price !== undefined && (price <= 0 || price >= 1)) {
+    console.error('Error: --price must be between 0 and 1 for outcome tokens');
+    process.exit(1);
+  }
+
+  if (szDecimals !== undefined && (szDecimals < 0 || szDecimals > 8)) {
+    console.error('Error: --sz-decimals must be between 0 and 8');
+    process.exit(1);
+  }
+
+  const client = getClient();
+  if (args.verbose) client.verbose = true;
+
+  const isBuy = side === 'buy';
+  const isMarket = price === undefined;
+
+  console.log('Open Broker - HIP-4 Outcome Order');
+  console.log('=================================\n');
+
+  await checkBuilderFeeApproval(client);
+
+  try {
+    const resolved = client.resolveOutcomeRef(outcomeRef, outcomeSide);
+    const market = await client.getOutcomeMarket(resolved.outcome);
+    const marketSide = market?.sides.find((s) => s.side === resolved.side);
+    const sideName = marketSide?.name ?? (resolved.side === 0 ? 'Yes' : 'No');
+    const midPrice = await client.getOutcomeMidPrice(resolved.outcome, resolved.side);
+    const slippageBps = slippage ?? 50;
+    const limitPrice = isMarket
+      ? (isBuy ? midPrice * (1 + slippageBps / 10000) : midPrice * (1 - slippageBps / 10000))
+      : price;
+    const notional = midPrice * size;
+
+    console.log('Order Details');
+    console.log('-------------');
+    console.log(`Outcome:      ${resolved.outcome}`);
+    console.log(`Market:       ${market?.name ?? 'Unknown'}${market?.parsedDescription.underlying ? ` (${market.parsedDescription.underlying})` : ''}`);
+    if (market?.parsedDescription.expiry) console.log(`Expiry:       ${market.parsedDescription.expiry}`);
+    if (market?.parsedDescription.targetPrice) console.log(`Target:       ${market.parsedDescription.targetPrice}`);
+    console.log(`Outcome Side: ${sideName.toUpperCase()} (${resolved.side})`);
+    console.log(`Coin:         ${resolved.coin}`);
+    console.log(`Asset ID:     ${resolved.assetId}`);
+    console.log(`Trade Side:   ${isBuy ? 'BUY' : 'SELL'}`);
+    console.log(`Size:         ${size}`);
+    console.log(`Mid Price:    ${formatOutcomePrice(midPrice)}`);
+    if (isMarket) {
+      console.log(`Type:         Market (IOC)`);
+      console.log(`Limit Price:  ${formatOutcomePrice(limitPrice)} (${slippageBps} bps slippage)`);
+    } else {
+      console.log(`Type:         Limit (${tif})`);
+      console.log(`Limit Price:  ${formatOutcomePrice(price)}`);
+    }
+    console.log(`Notional:     ~${formatUsd(notional)}`);
+    if (marketSide?.szDecimals !== undefined || szDecimals !== undefined) {
+      console.log(`Sz Decimals:  ${szDecimals ?? marketSide?.szDecimals}`);
+    }
+    console.log(`Builder Fee:  ${client.builderInfo.f / 10} bps`);
+
+    if (dryRun) {
+      console.log('\nDry run - order not submitted');
+      return;
+    }
+
+    console.log('\nExecuting...');
+
+    const response = isMarket
+      ? await client.outcomeMarketOrder(outcomeRef, outcomeSide, isBuy, size, slippage, szDecimals)
+      : await client.outcomeLimitOrder(outcomeRef, outcomeSide, isBuy, size, price!, tif, szDecimals);
+
+    console.log('\nResult');
+    console.log('------');
+
+    if (args.verbose || process.env.VERBOSE) {
+      console.log('\nFull Response:');
+      console.log(JSON.stringify(response, null, 2));
+    }
+
+    if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+      const statuses = response.response.data.statuses;
+      for (const status of statuses) {
+        if (status.filled) {
+          const fillSz = parseFloat(status.filled.totalSz);
+          const avgPx = parseFloat(status.filled.avgPx);
+          console.log('Filled');
+          console.log(`   Order ID:  ${status.filled.oid}`);
+          console.log(`   Size:      ${fillSz}`);
+          console.log(`   Avg Price: ${formatOutcomePrice(avgPx)}`);
+          console.log(`   Notional:  ${formatUsd(fillSz * avgPx)}`);
+        } else if (status.resting) {
+          console.log('Resting');
+          console.log(`   Order ID:  ${status.resting.oid}`);
+        } else if (status.error) {
+          console.log(`Error: ${status.error}`);
+        } else {
+          console.log('Unknown status:');
+          console.log(JSON.stringify(status, null, 2));
+        }
+      }
+    } else if (response.status === 'err') {
+      console.log(`API Error: ${response.response || JSON.stringify(response)}`);
+    } else {
+      console.log('Unexpected response:');
+      console.log(JSON.stringify(response, null, 2));
+    }
+  } catch (error) {
+    console.error('Error executing outcome order:', error);
+    console.error('Note: Hyperliquid currently documents outcomeMeta as testnet-only.');
+    process.exit(1);
+  }
+}
+
+main();