openbroker 1.0.54 → 1.0.56

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to Open Broker will be documented in this file.
 
+## [1.0.56] - 2026-03-10
+
+### Added
+- **Unified Account Support**: Detects and handles Hyperliquid's account abstraction modes (standard, unified, portfolio margin, dex abstraction)
+  - `getAccountMode()` / `isUnifiedAccount()` — queries `userAbstraction` API to detect mode
+  - **Unified accounts**: equity comes from `spotClearinghouseState` (single USDC balance shared across all dexes); skips `sendAsset` transfers for HIP-3 trading
+  - **Standard accounts**: keeps existing behavior (per-dex margin aggregation + USDC transfers)
+  - `account` command now displays the account abstraction mode
+- Prepares for deprecation of DEX abstraction mode per Hyperliquid docs
+
+## [1.0.55] - 2026-03-09
+
+### Added
+- **Leverage Control**: All trading commands now support `--leverage` flag to set leverage when opening positions
+  - Main perps: sets cross margin leverage before ordering
+  - HIP-3 perps: sets isolated margin at specified leverage (capped at asset's max)
+  - CLI: `--leverage 10` on `market`, `limit`, `trigger`, `bracket`, `chase`, `twap`, `scale`
+  - Plugin: `leverage` parameter on `ob_buy`, `ob_sell`, `ob_limit`, `ob_twap`, `ob_bracket`, `ob_chase`
+
 ## [1.0.54] - 2026-03-09
 
 ### Fixed

package/SKILL.md

@@ -4,7 +4,7 @@ description: Hyperliquid trading plugin with background position monitoring. Exe
 license: MIT
 compatibility: Requires Node.js 22+, network access to api.hyperliquid.xyz
 homepage: https://www.npmjs.com/package/openbroker
-metadata: {"author": "monemetrics", "version": "1.0.54", "openclaw": {"requires": {"bins": ["openbroker"], "env": ["HYPERLIQUID_PRIVATE_KEY"]}, "primaryEnv": "HYPERLIQUID_PRIVATE_KEY", "install": [{"id": "node", "kind": "node", "package": "openbroker", "bins": ["openbroker"], "label": "Install openbroker (npm)"}]}}
+metadata: {"author": "monemetrics", "version": "1.0.56", "openclaw": {"requires": {"bins": ["openbroker"], "env": ["HYPERLIQUID_PRIVATE_KEY"]}, "primaryEnv": "HYPERLIQUID_PRIVATE_KEY", "install": [{"id": "node", "kind": "node", "package": "openbroker", "bins": ["openbroker"], "label": "Install openbroker (npm)"}]}}
 allowed-tools: ob_account ob_positions ob_funding ob_markets ob_search ob_spot ob_fills ob_orders ob_order_status ob_fees ob_candles ob_funding_history ob_trades ob_rate_limit ob_funding_scan ob_buy ob_sell ob_limit ob_trigger ob_tpsl ob_cancel ob_twap ob_bracket ob_chase ob_watcher_status Bash(openbroker:*)
 ---
 

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openbroker",
   "name": "OpenBroker — Hyperliquid Trading",
-  "version": "1.0.54",
+  "version": "1.0.56",
   "description": "Trade on Hyperliquid DEX with background position monitoring",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbroker",
-  "version": "1.0.54",
+  "version": "1.0.56",
   "description": "Hyperliquid trading CLI - execute orders, manage positions, and run trading strategies",
   "type": "module",
   "bin": {

package/scripts/core/client.ts

@@ -35,6 +35,8 @@ export class HyperliquidClient {
   private hip3IsolatedSet: Set<string> = new Set();
   /** Cached maxLeverage for HIP-3 assets */
   private hip3MaxLeverageMap: Map<string, number> = new Map();
+  /** Cached account abstraction mode: 'standard' | 'unified' | 'portfolio' | 'dexAbstraction' */
+  private accountMode: string | null = null;
   public verbose: boolean = false;
 
   constructor(config?: OpenBrokerConfig) {
@@ -631,6 +633,57 @@ export class HyperliquidClient {
 
   // ============ Account Info ============
 
+  /**
+   * Get the account's abstraction mode.
+   * Returns: 'standard' | 'unified' | 'portfolio' | 'dexAbstraction'
+   * Unified accounts have a single USDC balance shared across all dexes.
+   * Standard accounts have separate balances per dex (need sendAsset transfers).
+   */
+  async getAccountMode(user?: string): Promise<string> {
+    if (this.accountMode) return this.accountMode;
+
+    const baseUrl = isMainnet()
+      ? 'https://api.hyperliquid.xyz'
+      : 'https://api.hyperliquid-testnet.xyz';
+
+    try {
+      const response = await fetch(baseUrl + '/info', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'userAbstraction',
+          user: user ?? this.address,
+        }),
+      });
+      const data = await response.json();
+      this.log('userAbstraction response:', data);
+
+      // API returns: "default" | "disabled" | "dexAbstraction" | "unifiedAccount" | "portfolioMargin"
+      if (data === 'unifiedAccount') {
+        this.accountMode = 'unified';
+      } else if (data === 'portfolioMargin') {
+        this.accountMode = 'portfolio';
+      } else if (data === 'dexAbstraction') {
+        this.accountMode = 'dexAbstraction';
+      } else {
+        // "default" or "disabled" both mean standard mode
+        this.accountMode = 'standard';
+      }
+    } catch (err) {
+      this.log('Failed to fetch account abstraction mode:', err instanceof Error ? err.message : String(err));
+      this.accountMode = 'standard'; // Safe fallback
+    }
+
+    this.log('Account mode:', this.accountMode);
+    return this.accountMode;
+  }
+
+  /** Whether the account uses unified balances (unified or portfolio margin) */
+  async isUnifiedAccount(user?: string): Promise<boolean> {
+    const mode = await this.getAccountMode(user);
+    return mode === 'unified' || mode === 'portfolio';
+  }
+
   /**
    * Check if an address has sub-accounts (is a master account)
    * Sub-accounts cannot approve builder fees - only master accounts can
@@ -1075,14 +1128,17 @@ export class HyperliquidClient {
 
   /**
    * Get user state across all dexes (main + HIP-3).
-   * Merges HIP-3 positions into assetPositions and aggregates margin summaries.
+   * For unified accounts: equity comes from spotClearinghouseState (single USDC balance).
+   * For standard accounts: aggregates margin summaries from each dex.
    */
   async getUserStateAll(user?: string): Promise<ClearinghouseState> {
     await this.getMetaAndAssetCtxs(); // Ensure HIP-3 dex list is loaded
 
+    const unified = await this.isUnifiedAccount(user);
     const mainState = await this.getUserState(user);
     const dexs = await this.getPerpDexs();
 
+    // Collect positions from all HIP-3 dexes
     for (let i = 1; i < dexs.length; i++) {
       const dex = dexs[i];
       if (!dex) continue;
@@ -1093,24 +1149,63 @@ export class HyperliquidClient {
           mainState.assetPositions.push(...dexState.assetPositions);
         }
 
-        // Aggregate margin summaries from HIP-3 dexes
-        const dexMargin = dexState.marginSummary;
-        if (dexMargin) {
-          const addToSummary = (summary: { accountValue: string; totalNtlPos: string; totalRawUsd: string; totalMarginUsed: string; withdrawable: string }) => {
-            summary.accountValue = String(parseFloat(summary.accountValue) + parseFloat(dexMargin.accountValue));
-            summary.totalNtlPos = String(parseFloat(summary.totalNtlPos) + parseFloat(dexMargin.totalNtlPos));
-            summary.totalRawUsd = String(parseFloat(summary.totalRawUsd) + parseFloat(dexMargin.totalRawUsd));
-            summary.totalMarginUsed = String(parseFloat(summary.totalMarginUsed) + parseFloat(dexMargin.totalMarginUsed));
-            summary.withdrawable = String(parseFloat(summary.withdrawable) + parseFloat(dexMargin.withdrawable));
-          };
-          addToSummary(mainState.marginSummary);
-          addToSummary(mainState.crossMarginSummary);
+        // For standard accounts, aggregate margin from each dex
+        if (!unified) {
+          const dexMargin = dexState.marginSummary;
+          if (dexMargin) {
+            const addToSummary = (summary: { accountValue: string; totalNtlPos: string; totalRawUsd: string; totalMarginUsed: string; withdrawable: string }) => {
+              summary.accountValue = String(parseFloat(summary.accountValue) + parseFloat(dexMargin.accountValue));
+              summary.totalNtlPos = String(parseFloat(summary.totalNtlPos) + parseFloat(dexMargin.totalNtlPos));
+              summary.totalRawUsd = String(parseFloat(summary.totalRawUsd) + parseFloat(dexMargin.totalRawUsd));
+              summary.totalMarginUsed = String(parseFloat(summary.totalMarginUsed) + parseFloat(dexMargin.totalMarginUsed));
+              summary.withdrawable = String(parseFloat(summary.withdrawable) + parseFloat(dexMargin.withdrawable));
+            };
+            addToSummary(mainState.marginSummary);
+            addToSummary(mainState.crossMarginSummary);
+          }
         }
       } catch (err) {
         this.log(`Failed to fetch state for dex ${dex.name}:`, err instanceof Error ? err.message : String(err));
       }
     }
 
+    // For unified accounts: equity is the USDC balance from spot clearinghouse
+    if (unified) {
+      try {
+        const spotState = await this.getSpotBalances(user);
+        const usdcBalance = spotState.balances.find(b => b.coin === 'USDC');
+        if (usdcBalance) {
+          const totalUsdc = usdcBalance.total;
+          const holdUsdc = usdcBalance.hold;
+          const withdrawable = String(parseFloat(totalUsdc) - parseFloat(holdUsdc));
+
+          // Compute total margin used and notional from all positions
+          let totalMarginUsed = 0;
+          let totalNtlPos = 0;
+          for (const ap of mainState.assetPositions) {
+            const pos = ap.position;
+            if (parseFloat(pos.szi) === 0) continue;
+            totalMarginUsed += parseFloat(pos.marginUsed);
+            totalNtlPos += Math.abs(parseFloat(pos.positionValue));
+          }
+
+          const summary = {
+            accountValue: totalUsdc,
+            totalNtlPos: String(totalNtlPos),
+            totalRawUsd: totalUsdc,
+            totalMarginUsed: String(totalMarginUsed),
+            withdrawable,
+          };
+          mainState.marginSummary = summary;
+          mainState.crossMarginSummary = { ...summary };
+
+          this.log(`Unified account: USDC balance $${parseFloat(totalUsdc).toFixed(2)}, margin used $${totalMarginUsed.toFixed(2)}`);
+        }
+      } catch (err) {
+        this.log('Failed to fetch spot balances for unified account:', err instanceof Error ? err.message : String(err));
+      }
+    }
+
     return mainState;
   }
 
@@ -1123,22 +1218,25 @@ export class HyperliquidClient {
   // ============ Trading ============
 
   /**
-   * HIP-3 perps have independent margin per dex. Before ordering:
+   * HIP-3 perps: prepare for trading.
    * 1. Set isolated margin mode (required for HIP-3)
-   * 2. Transfer USDC from main perp to the HIP-3 dex (each dex has its own balance)
+   * 2. For standard accounts only: transfer USDC from main perp to HIP-3 dex
+   *    (unified accounts share USDC across all dexes automatically)
    */
-  private async ensureHip3Ready(coin: string, notional: number): Promise<void> {
+  private async ensureHip3Ready(coin: string, notional: number, leverage?: number): Promise<void> {
     if (!this.isHip3(coin)) return;
 
     const dexInfo = this.coinDexMap.get(coin);
     if (!dexInfo?.dexName) return;
 
-    // Set isolated margin on first order per asset
-    if (!this.hip3IsolatedSet.has(coin)) {
-      const maxLev = this.hip3MaxLeverageMap.get(coin) ?? 10;
-      this.log(`HIP-3 asset ${coin} (dex: ${dexInfo.dexName}) — setting isolated margin at ${maxLev}x`);
+    const maxLev = this.hip3MaxLeverageMap.get(coin) ?? 10;
+    const effectiveLev = Math.min(leverage ?? maxLev, maxLev);
+
+    // Set isolated margin on first order per asset, or when leverage changes
+    if (!this.hip3IsolatedSet.has(coin) || leverage) {
+      this.log(`HIP-3 asset ${coin} (dex: ${dexInfo.dexName}) — setting isolated margin at ${effectiveLev}x`);
       try {
-        await this.updateLeverage(coin, maxLev, false); // false = isolated
+        await this.updateLeverage(coin, effectiveLev, false); // false = isolated
         this.hip3IsolatedSet.add(coin);
       } catch (err) {
         this.log(`Failed to set isolated margin for ${coin}:`, err instanceof Error ? err.message : String(err));
@@ -1146,13 +1244,19 @@ export class HyperliquidClient {
       }
     }
 
-    // Transfer USDC to the HIP-3 dex to cover margin
-    const maxLev = this.hip3MaxLeverageMap.get(coin) ?? 10;
-    const requiredMargin = notional / maxLev;
+    // Unified accounts share USDC across all dexes — no transfer needed
+    const unified = await this.isUnifiedAccount();
+    if (unified) {
+      this.log(`Unified account — skipping USDC transfer for ${coin} (shared balance)`);
+      return;
+    }
+
+    // Standard accounts: transfer USDC to the HIP-3 dex to cover margin
+    const requiredMargin = notional / effectiveLev;
     // Add 20% buffer for fees and slippage
     const transferAmount = Math.ceil(requiredMargin * 1.2 * 100) / 100;
 
-    this.log(`HIP-3 margin transfer: ${transferAmount} USDC from main → ${dexInfo.dexName} (notional: ${notional}, leverage: ${maxLev}x)`);
+    this.log(`HIP-3 margin transfer: ${transferAmount} USDC from main → ${dexInfo.dexName} (notional: ${notional}, leverage: ${effectiveLev}x)`);
     try {
       await this.exchange.sendAsset({
         destination: this.address as `0x${string}`,
@@ -1175,13 +1279,20 @@ export class HyperliquidClient {
     price: number,
     orderType: { limit: { tif: 'Gtc' | 'Ioc' | 'Alo' } },
     reduceOnly: boolean = false,
-    includeBuilder: boolean = true
+    includeBuilder: boolean = true,
+    leverage?: number
   ): Promise<OrderResponse> {
     this.requireTrading();
     await this.getMetaAndAssetCtxs();
 
+    // Set leverage if specified (for main perps, cross margin; for HIP-3, handled in ensureHip3Ready)
+    if (leverage && !this.isHip3(coin)) {
+      this.log(`Setting leverage for ${coin} to ${leverage}x cross`);
+      await this.updateLeverage(coin, leverage, true);
+    }
+
     // HIP-3 perps: set isolated margin + transfer USDC to dex
-    await this.ensureHip3Ready(coin, size * price);
+    await this.ensureHip3Ready(coin, size * price, leverage);
 
     const assetIndex = this.getAssetIndex(coin);
     const szDecimals = this.getSzDecimals(coin);
@@ -1230,7 +1341,8 @@ export class HyperliquidClient {
     coin: string,
     isBuy: boolean,
     size: number,
-    slippageBps?: number
+    slippageBps?: number,
+    leverage?: number
   ): Promise<OrderResponse> {
     await this.getMetaAndAssetCtxs();
 
@@ -1256,7 +1368,8 @@ export class HyperliquidClient {
       limitPrice,
       { limit: { tif: 'Ioc' } },
       false,
-      true
+      true,
+      leverage
     );
   }
 
@@ -1266,7 +1379,8 @@ export class HyperliquidClient {
     size: number,
     price: number,
     tif: 'Gtc' | 'Ioc' | 'Alo' = 'Gtc',
-    reduceOnly: boolean = false
+    reduceOnly: boolean = false,
+    leverage?: number
   ): Promise<OrderResponse> {
     return this.order(
       coin,
@@ -1275,7 +1389,8 @@ export class HyperliquidClient {
       price,
       { limit: { tif } },
       reduceOnly,
-      true
+      true,
+      leverage
     );
   }
 
@@ -1296,13 +1411,20 @@ export class HyperliquidClient {
     triggerPrice: number,
     limitPrice: number,
     tpsl: 'tp' | 'sl',
-    reduceOnly: boolean = true
+    reduceOnly: boolean = true,
+    leverage?: number
   ): Promise<OrderResponse> {
     this.requireTrading();
     await this.getMetaAndAssetCtxs();
 
+    // Set leverage if specified (for main perps)
+    if (leverage && !this.isHip3(coin)) {
+      this.log(`Setting leverage for ${coin} to ${leverage}x cross`);
+      await this.updateLeverage(coin, leverage, true);
+    }
+
     // HIP-3 perps: set isolated margin + transfer USDC to dex
-    await this.ensureHip3Ready(coin, size * limitPrice);
+    await this.ensureHip3Ready(coin, size * limitPrice, leverage);
 
     const assetIndex = this.getAssetIndex(coin);
     const szDecimals = this.getSzDecimals(coin);

package/scripts/info/account.ts

@@ -17,6 +17,15 @@ async function main() {
   console.log(`Signing Wallet:   ${client.walletAddress}`);
   console.log(`Wallet Type:      ${client.isApiWallet ? 'API Wallet' : 'Main Wallet'}`);
 
+  const accountMode = await client.getAccountMode();
+  const modeLabel: Record<string, string> = {
+    standard: 'Standard (separate balances per dex)',
+    unified: 'Unified Account (shared USDC across all dexes)',
+    portfolio: 'Portfolio Margin',
+    dexAbstraction: 'DEX Abstraction (deprecated)',
+  };
+  console.log(`Account Mode:     ${modeLabel[accountMode] ?? accountMode}`);
+
   // Check builder fee approval
   const builderApproval = await client.getMaxBuilderFee();
   console.log(`Builder Address:  ${client.builderAddress}`);

package/scripts/operations/bracket.ts

@@ -24,6 +24,7 @@ Options:
   --tp          Take profit distance in % from entry
   --sl          Stop loss distance in % from entry
   --slippage    Slippage for market entry in bps (default: 50)
+  --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --dry         Dry run - show bracket plan without executing
 
 Take Profit / Stop Loss:
@@ -66,6 +67,7 @@ async function main() {
   const tpPct = parseFloat(args.tp as string);
   const slPct = parseFloat(args.sl as string);
   const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
+  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const dryRun = args.dry as boolean;
 
   if (!coin || !side || isNaN(size) || isNaN(tpPct) || isNaN(slPct)) {
@@ -171,7 +173,7 @@ async function main() {
     let actualEntry = entry;
 
     if (entryType === 'market') {
-      const entryResponse = await client.marketOrder(coin, isLong, size, slippage);
+      const entryResponse = await client.marketOrder(coin, isLong, size, slippage, leverage);
 
       if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
         const status = entryResponse.response.data.statuses[0];
@@ -189,7 +191,7 @@ async function main() {
         process.exit(1);
       }
     } else {
-      const entryResponse = await client.limitOrder(coin, isLong, size, entry, 'Gtc', false);
+      const entryResponse = await client.limitOrder(coin, isLong, size, entry, 'Gtc', false, leverage);
 
       if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
         const status = entryResponse.response.data.statuses[0];

package/scripts/operations/chase.ts

@@ -23,6 +23,7 @@ Options:
   --timeout     Max time to chase in seconds (default: 300 = 5 min)
   --interval    Update interval in ms (default: 2000)
   --max-chase   Max price to chase to in bps from start (default: 100 = 1%)
+  --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --reduce      Reduce-only order
   --dry         Dry run - show chase parameters without executing
 
@@ -54,6 +55,7 @@ async function main() {
   const timeoutSec = args.timeout ? parseInt(args.timeout as string) : 300;
   const intervalMs = args.interval ? parseInt(args.interval as string) : 2000;
   const maxChaseBps = args['max-chase'] ? parseInt(args['max-chase'] as string) : 100;
+  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const reduceOnly = args.reduce as boolean;
   const dryRun = args.dry as boolean;
 
@@ -168,7 +170,7 @@ async function main() {
         // Place new order
         process.stdout.write(`[${iteration}] Mid: ${formatUsd(currentMid)} → Order: ${formatUsd(orderPrice)}... `);
 
-        const response = await client.limitOrder(coin, isBuy, size, orderPrice, 'Alo', reduceOnly);
+        const response = await client.limitOrder(coin, isBuy, size, orderPrice, 'Alo', reduceOnly, leverage);
 
         if (response.status === 'ok' && response.response && typeof response.response === 'object') {
           const status = response.response.data.statuses[0];

package/scripts/operations/limit-order.ts

@@ -23,6 +23,7 @@ Options:
               GTC = Good Till Cancel (rests on book)
               IOC = Immediate Or Cancel (fills or cancels)
               ALO = Add Liquidity Only (post-only, maker only)
+  --leverage  Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --reduce    Reduce-only order (default: false)
   --dry       Dry run - show order details without executing
 
@@ -42,6 +43,7 @@ async function main() {
   const size = parseFloat(args.size as string);
   const price = parseFloat(args.price as string);
   const tifArg = (args.tif as string)?.toUpperCase() || 'GTC';
+  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const reduceOnly = args.reduce as boolean;
   const dryRun = args.dry as boolean;
 
@@ -107,6 +109,7 @@ async function main() {
     console.log(`Notional:       ${formatUsd(notional)}`);
     console.log(`Time in Force:  ${tif}`);
     console.log(`Reduce Only:    ${reduceOnly ? 'Yes' : 'No'}`);
+    if (leverage) console.log(`Leverage:       ${leverage}x`);
     console.log(`Builder Fee:    ${client.builderInfo.f / 10} bps`);
 
     // Warning if order would be aggressively priced
@@ -121,7 +124,7 @@ async function main() {
 
     console.log('\nSubmitting...');
 
-    const response = await client.limitOrder(coin, isBuy, size, price, tif, reduceOnly);
+    const response = await client.limitOrder(coin, isBuy, size, price, tif, reduceOnly, leverage);
 
     console.log('\nResult');
     console.log('------');

package/scripts/operations/market-order.ts

@@ -19,6 +19,7 @@ Options:
   --side      Order side: buy or sell
   --size      Order size in base asset
   --slippage  Slippage tolerance in bps (default: from config, usually 50 = 0.5%)
+  --leverage  Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --reduce    Reduce-only order (default: false)
   --dry       Dry run - show order details without executing
   --verbose   Show full API request/response for debugging
@@ -44,6 +45,7 @@ async function main() {
   const side = args.side as string;
   const size = parseFloat(args.size as string);
   const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
+  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const reduceOnly = args.reduce as boolean;
   const dryRun = args.dry as boolean;
 
@@ -103,6 +105,7 @@ async function main() {
     console.log(`Limit Price:  ${formatUsd(limitPrice)} (${slippageBps} bps slippage)`);
     console.log(`Notional:     ~${formatUsd(notional)}`);
     console.log(`Reduce Only:  ${reduceOnly ? 'Yes' : 'No'}`);
+    if (leverage) console.log(`Leverage:     ${leverage}x`);
     console.log(`Builder Fee:  ${client.builderInfo.f / 10} bps`);
 
     if (dryRun) {
@@ -112,7 +115,7 @@ async function main() {
 
     console.log('\nExecuting...');
 
-    const response = await client.marketOrder(coin, isBuy, size, slippage);
+    const response = await client.marketOrder(coin, isBuy, size, slippage, leverage);
 
     console.log('\nResult');
     console.log('------');

package/scripts/operations/scale.ts

@@ -25,6 +25,7 @@ Options:
                   - linear: more size at better prices
                   - exponential: much more size at better prices
                   - flat: equal size at all levels
+  --leverage      Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --reduce        Reduce-only orders (for scaling out of position)
   --tif           Time in force: GTC, ALO (default: GTC)
   --dry           Dry run - show order plan without executing
@@ -108,6 +109,7 @@ async function main() {
   const numLevels = parseInt(args.levels as string);
   const rangePct = parseFloat(args.range as string);
   const distribution = (args.distribution as string || 'linear') as 'linear' | 'exponential' | 'flat';
+  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const reduceOnly = args.reduce as boolean;
   const tifArg = ((args.tif as string)?.toUpperCase() || 'GTC');
   const dryRun = args.dry as boolean;
@@ -208,7 +210,8 @@ async function main() {
           level.size,
           level.price,
           tif,
-          reduceOnly
+          reduceOnly,
+          leverage
         );
 
         if (response.status === 'ok' && response.response && typeof response.response === 'object') {

package/scripts/operations/trigger-order.ts

@@ -23,6 +23,7 @@ Options:
   --type        Order type: tp (take profit) or sl (stop loss)
   --limit       Limit price when triggered (default: trigger price for TP, with slippage for SL)
   --slippage    Slippage for SL in bps (default: 100 = 1%)
+  --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --reduce      Reduce-only order (default: true for TP/SL)
   --dry         Dry run - show order without placing
 
@@ -62,6 +63,7 @@ async function main() {
   const orderType = args.type as string;
   const limitPriceOverride = args.limit ? parseFloat(args.limit as string) : undefined;
   const slippageBps = args.slippage ? parseInt(args.slippage as string) : 100;
+  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const reduceOnly = args.reduce !== 'false'; // Default true
   const dryRun = args.dry as boolean;
 
@@ -167,7 +169,8 @@ async function main() {
       triggerPrice,
       limitPrice,
       tpsl,
-      reduceOnly
+      reduceOnly,
+      leverage
     );
 
     console.log('\nResult');

package/scripts/operations/twap.ts

@@ -23,6 +23,7 @@ Options:
   --intervals   Number of slices (default: calculates based on duration)
   --randomize   Randomize timing by ±X percent (default: 0)
   --slippage    Slippage tolerance in bps per slice (default: 50)
+  --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --dry         Dry run - show execution plan without trading
 
 Examples:
@@ -57,6 +58,7 @@ async function main() {
   const intervals = args.intervals ? parseInt(args.intervals as string) : Math.max(6, Math.floor(duration / 300)); // default: 1 slice per 5 min
   const randomize = args.randomize ? parseInt(args.randomize as string) : 0;
   const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
+  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const dryRun = args.dry as boolean;
 
   if (!coin || !side || isNaN(totalSize) || isNaN(duration)) {
@@ -146,7 +148,7 @@ async function main() {
       };
 
       try {
-        const response = await client.marketOrder(coin, isBuy, sliceSize, slippage);
+        const response = await client.marketOrder(coin, isBuy, sliceSize, slippage, leverage);
 
         if (response.status === 'ok' && response.response && typeof response.response === 'object') {
           const statuses = response.response.data.statuses;

package/scripts/plugin/tools.ts

@@ -743,6 +743,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
           coin: { type: 'string', description: 'Asset symbol (ETH, BTC, SOL, etc.)' },
           size: { type: 'number', description: 'Order size in base asset' },
           slippage: { type: 'number', description: 'Slippage tolerance in bps (default: 50)' },
+          leverage: { type: 'number', description: 'Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3' },
           dry: { type: 'boolean', description: 'Preview without executing' },
         },
         required: ['coin', 'size'],
@@ -757,6 +758,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
         const coin = normalizeCoin(params.coin as string);
         const size = params.size as number;
         const slippageBps = (params.slippage as number) ?? client.builderInfo.f;
+        const leverage = params.leverage as number | undefined;
 
         const mids = await client.getAllMids();
         const midPrice = parseFloat(mids[coin]);
@@ -775,11 +777,12 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
             midPrice,
             slippagePrice,
             slippageBps,
+            leverage,
           });
         }
 
-        const result = await client.marketOrder(coin, true, parseFloat(roundedSize), slippageBps);
-        return json({ action: 'buy', coin, size: roundedSize, result });
+        const result = await client.marketOrder(coin, true, parseFloat(roundedSize), slippageBps, leverage);
+        return json({ action: 'buy', coin, size: roundedSize, leverage, result });
       },
     },
 
@@ -792,6 +795,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
           coin: { type: 'string', description: 'Asset symbol (ETH, BTC, SOL, etc.)' },
           size: { type: 'number', description: 'Order size in base asset' },
           slippage: { type: 'number', description: 'Slippage tolerance in bps (default: 50)' },
+          leverage: { type: 'number', description: 'Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3' },
           dry: { type: 'boolean', description: 'Preview without executing' },
         },
         required: ['coin', 'size'],
@@ -806,6 +810,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
         const coin = normalizeCoin(params.coin as string);
         const size = params.size as number;
         const slippageBps = (params.slippage as number) ?? client.builderInfo.f;
+        const leverage = params.leverage as number | undefined;
 
         const mids = await client.getAllMids();
         const midPrice = parseFloat(mids[coin]);
@@ -824,11 +829,12 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
             midPrice,
             slippagePrice,
             slippageBps,
+            leverage,
           });
         }
 
-        const result = await client.marketOrder(coin, false, parseFloat(roundedSize), slippageBps);
-        return json({ action: 'sell', coin, size: roundedSize, result });
+        const result = await client.marketOrder(coin, false, parseFloat(roundedSize), slippageBps, leverage);
+        return json({ action: 'sell', coin, size: roundedSize, leverage, result });
       },
     },
 
@@ -843,6 +849,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
           size: { type: 'number', description: 'Order size in base asset' },
           price: { type: 'number', description: 'Limit price' },
           tif: { type: 'string', enum: ['GTC', 'IOC', 'ALO'], description: 'Time in force (default: GTC)' },
+          leverage: { type: 'number', description: 'Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3' },
           reduce: { type: 'boolean', description: 'Reduce-only order' },
           dry: { type: 'boolean', description: 'Preview without executing' },
         },
@@ -860,6 +867,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
         const size = params.size as number;
         const price = params.price as number;
         const tif = ((params.tif as string) || 'GTC').toLowerCase();
+        const leverage = params.leverage as number | undefined;
         const reduceOnly = (params.reduce as boolean) || false;
 
         const szDecimals = await client.getSzDecimals(coin);
@@ -884,9 +892,9 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
         }
 
         const result = await client.limitOrder(
-          coin, isBuy, parseFloat(roundedSize), parseFloat(roundedPrice), sdkTif, reduceOnly,
+          coin, isBuy, parseFloat(roundedSize), parseFloat(roundedPrice), sdkTif, reduceOnly, leverage,
         );
-        return json({ action: 'limit', coin, side: params.side, size: roundedSize, price: roundedPrice, result });
+        return json({ action: 'limit', coin, side: params.side, size: roundedSize, price: roundedPrice, leverage, result });
       },
     },
 
@@ -1068,6 +1076,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
           duration: { type: 'number', description: 'Duration in seconds' },
           intervals: { type: 'number', description: 'Number of slices' },
           randomize: { type: 'number', description: 'Randomize timing by this % (0-50)' },
+          leverage: { type: 'number', description: 'Set leverage (e.g., 10 for 10x)' },
           dry: { type: 'boolean', description: 'Preview without executing' },
         },
         required: ['coin', 'side', 'size', 'duration'],
@@ -1102,6 +1111,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
           sl: { type: 'number', description: 'Stop loss percentage from entry' },
           entry: { type: 'string', enum: ['market', 'limit'], description: 'Entry type (default: market)' },
           price: { type: 'number', description: 'Entry price (required if entry=limit)' },
+          leverage: { type: 'number', description: 'Set leverage (e.g., 10 for 10x)' },
           dry: { type: 'boolean', description: 'Preview without executing' },
         },
         required: ['coin', 'side', 'size', 'tp', 'sl'],
@@ -1134,6 +1144,7 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
           size: { type: 'number', description: 'Order size' },
           offset: { type: 'number', description: 'Tick offset from best price (default: 1)' },
           timeout: { type: 'number', description: 'Timeout in seconds' },
+          leverage: { type: 'number', description: 'Set leverage (e.g., 10 for 10x)' },
           dry: { type: 'boolean', description: 'Preview without executing' },
         },
         required: ['coin', 'side', 'size'],