openbroker 1.0.85 → 1.0.88

package/SKILL.md

@@ -4,7 +4,7 @@ description: Hyperliquid trading plugin with background position monitoring and
 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.85", "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.88", "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_spot_buy ob_spot_sell ob_twap ob_twap_cancel ob_twap_status ob_bracket ob_chase ob_watcher_status ob_auto_run ob_auto_stop ob_auto_list Bash(openbroker:*)
 ---
 

package/openclaw.plugin.json

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

package/package.json

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

package/scripts/auto/report.ts

@@ -338,12 +338,12 @@ function renderTextReport(data: ReturnType<typeof loadReport>, watchMode = false
   console.log('\nEquity');
   console.log('------');
   if (report.equity.first) {
-    console.log(`First snapshot: ${formatUsd(report.equity.first.equity)} @ ${formatTimestamp(Number(report.equity.first.timestamp))}`);
+    console.log(`First snapshot: ${formatUsd(Number(report.equity.first.equity))} @ ${formatTimestamp(Number(report.equity.first.timestamp))}`);
   } else {
     console.log('First snapshot: -');
   }
   if (report.equity.latest) {
-    console.log(`Latest snapshot:${formatUsd(report.equity.latest.equity)} @ ${formatTimestamp(Number(report.equity.latest.timestamp))}`);
+    console.log(`Latest snapshot:${formatUsd(Number(report.equity.latest.equity))} @ ${formatTimestamp(Number(report.equity.latest.timestamp))}`);
   } else {
     console.log('Latest snapshot:-');
   }

package/scripts/auto/runtime.ts

@@ -569,21 +569,19 @@ export async function startAutomation(options: RuntimeOptions): Promise<RunningA
           }, 'ws');
         }
 
-        // Also emit order_filled for backward compatibility
-        if (update.status === 'filled' && eventBus.has('order_filled')) {
-          void emitAutomationEvent('order_filled', {
-            coin: update.order.coin,
-            oid: update.order.oid,
-            side: update.order.side === 'B' ? 'buy' : 'sell',
-            size: parseFloat(update.order.sz),
-            price: parseFloat(update.order.limitPx),
-          }, 'ws');
-        }
+        // NOTE: order_filled is emitted from the userFill handler below, not from
+        // here. The previous implementation fired it from orderUpdate.status
+        // === 'filled' using update.order.sz as the size, but that field is the
+        // REMAINING size (0 on a terminal fill), not the fill delta — so every
+        // consumer saw size=0. Additionally, Hyperliquid does not emit
+        // orderUpdate events for pure partial fills that don't transition
+        // status, so partial fills were silently dropped entirely. Sourcing
+        // order_filled from userFill fixes both issues: sz there IS the fill
+        // delta, and the userFills stream fires on every fill (partial and
+        // terminal).
       });
 
       ws.on('userFill', (fill) => {
-        // userFill events are already covered by order_update with status=filled
-        // But this provides the realized PnL and fee data that order_update doesn't have
         audit.recordFill({
           coin: fill.coin,
           side: fill.side === 'B' ? 'buy' : 'sell',
@@ -596,6 +594,40 @@ export async function startAutomation(options: RuntimeOptions): Promise<RunningA
           crossed: fill.crossed,
         }, fill.time);
         log.debug(`Fill: ${fill.side === 'B' ? 'BUY' : 'SELL'} ${fill.sz} ${fill.coin} @ ${fill.px} (PnL: ${fill.closedPnl})`);
+
+        // Emit order_filled with the authoritative fill delta + fee/pnl from
+        // the userFills WS stream. Covers both partial and terminal fills.
+        // Fee is converted to USD using feeToken: for non-USDC fees (spot
+        // buys pay in the received asset), fee × price yields USD since the
+        // fee token is the base of the traded pair and `price` is quote/base.
+        if (eventBus.has('order_filled')) {
+          const size = parseFloat(fill.sz);
+          const price = parseFloat(fill.px);
+          const rawFee = parseFloat(fill.fee);
+          const closedPnl = parseFloat(fill.closedPnl);
+          const feeToken = fill.feeToken;
+          let feeUsd: number | undefined;
+          if (Number.isFinite(rawFee)) {
+            if (feeToken === 'USDC' || !feeToken) {
+              feeUsd = rawFee;
+            } else if (Number.isFinite(price) && price > 0) {
+              feeUsd = rawFee * price;
+            } else {
+              feeUsd = undefined;
+            }
+          }
+          void emitAutomationEvent('order_filled', {
+            coin: fill.coin,
+            oid: fill.oid,
+            side: fill.side === 'B' ? 'buy' : 'sell',
+            size,
+            price,
+            fee: feeUsd,
+            feeToken,
+            closedPnl: Number.isFinite(closedPnl) ? closedPnl : undefined,
+            crossed: fill.crossed,
+          }, 'ws');
+        }
       });
 
       ws.on('userEvent', (event) => {

package/scripts/auto/types.ts

@@ -46,7 +46,29 @@ export interface AutomationEventPayloads {
   position_changed: { coin: string; oldSize: number; newSize: number; entryPrice: number };
   pnl_threshold: { coin: string; unrealizedPnl: number; changePct: number; positionValue: number };
   margin_warning: { marginUsedPct: number; equity: number; marginUsed: number };
-  order_filled: { coin: string; oid: number; side: 'buy' | 'sell'; size: number; price: number };
+  /**
+   * Fires on every trade fill — partial and terminal — sourced from the
+   * Hyperliquid `userFills` WS stream. `size` is the fill delta (NOT remaining
+   * size of the order). `fee` and `closedPnl` are in USD (converted from the
+   * raw fee denomination using `price` when `feeToken !== "USDC"`, which
+   * happens on spot buys where the fee is charged in the received asset).
+   * `feeToken` is the original denomination so consumers can identify legs
+   * that won't carry a builder fee (Hyperliquid only charges builder fees on
+   * USDC-denominated trades). `crossed` is true when this side was the taker.
+   * Fee/pnl/crossed/feeToken are optional so older consumers that only read
+   * coin/oid/side/size/price keep working.
+   */
+  order_filled: {
+    coin: string;
+    oid: number;
+    side: 'buy' | 'sell';
+    size: number;
+    price: number;
+    fee?: number;
+    feeToken?: string;
+    closedPnl?: number;
+    crossed?: boolean;
+  };
   /** Real-time order lifecycle event via WebSocket (filled, canceled, rejected, triggered, etc.) */
   order_update: {
     coin: string;

package/scripts/core/client.ts

@@ -9,6 +9,8 @@ import type {
   OrderResponse,
   CancelResponse,
   MetaAndAssetCtxs,
+  AssetMeta,
+  AssetCtx,
   ClearinghouseState,
   OpenOrder,
 } from './types.js';
@@ -256,13 +258,16 @@ export class HyperliquidClient {
     }
     this.log('metaAndAssetCtxs response:', JSON.stringify(response, null, 2).slice(0, 500) + '...');
 
-    this.meta = {
-      meta: { universe: response[0].universe },
-      assetCtxs: response[1],
+    // Build the narrowed value locally so neither narrowing nor the `| null`
+    // field type can be lost across `await` / method-call boundaries below.
+    const meta: MetaAndAssetCtxs = {
+      meta: { universe: response[0].universe as AssetMeta[] },
+      assetCtxs: response[1] as AssetCtx[],
     };
+    this.meta = meta;
 
     // Build lookup maps for main dex
-    this.meta.meta.universe.forEach((asset, index) => {
+    meta.meta.universe.forEach((asset, index) => {
       this.assetMap.set(asset.name, index);
       this.szDecimalsMap.set(asset.name, asset.szDecimals);
       this.coinDexMap.set(asset.name, { dexName: null, dexIdx: 0, localName: asset.name });
@@ -274,7 +279,7 @@ export class HyperliquidClient {
       this.hip3Loaded = true;
     }
 
-    return this.meta;
+    return meta;
   }
 
   /**
@@ -782,7 +787,19 @@ export class HyperliquidClient {
           tokenId,
         }),
       });
-      const data = await response.json();
+      const data = await response.json() as {
+        name: string;
+        maxSupply: string;
+        totalSupply: string;
+        circulatingSupply: string;
+        szDecimals: number;
+        weiDecimals: number;
+        midPx: string;
+        markPx: string;
+        prevDayPx: string;
+        deployer: string;
+        deployTime: string;
+      } | null;
       this.log('tokenDetails response:', JSON.stringify(data).slice(0, 500));
       return data;
     } catch {
@@ -807,7 +824,10 @@ export class HyperliquidClient {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ type: 'predictedFundings' }),
     });
-    const data = await response.json();
+    const data = await response.json() as Array<[
+      string,
+      Array<[string, { fundingRate: string; nextFundingTime: number }]>
+    ]>;
     this.log('predictedFundings response length:', data?.length);
     return data;
   }
@@ -827,7 +847,7 @@ export class HyperliquidClient {
   }> {
     this.log('Fetching l2Book for:', coin);
     // API accepts prefixed names directly (e.g., "xyz:CL")
-    let response;
+    let response: Awaited<ReturnType<typeof this.info.l2Book>>;
     try {
       response = await this.info.l2Book({ coin });
     } catch (error) {
@@ -838,8 +858,12 @@ export class HyperliquidClient {
       throw new Error(`l2Book(${coin}) failed: ${this.describeError(error)}`);
     }
 
-    const bids = response.levels[0] as Array<{ px: string; sz: string; n: number }>;
-    const asks = response.levels[1] as Array<{ px: string; sz: string; n: number }>;
+    if (!response || !Array.isArray(response.levels)) {
+      throw new Error(`l2Book(${coin}) returned empty/malformed payload.`);
+    }
+
+    const bids = (response.levels[0] ?? []) as Array<{ px: string; sz: string; n: number }>;
+    const asks = (response.levels[1] ?? []) as Array<{ px: string; sz: string; n: number }>;
 
     const bestBid = bids.length > 0 ? parseFloat(bids[0].px) : 0;
     const bestAsk = asks.length > 0 ? parseFloat(asks[0].px) : 0;
@@ -1015,7 +1039,7 @@ export class HyperliquidClient {
           user: user ?? this.address,
         }),
       });
-      const data = await response.json();
+      const data = await response.json() as string | { abstraction?: string; mode?: string } | null;
       this.log('userAbstraction response:', JSON.stringify(data));
 
       // API may return a bare string or an object. Normalize to string for matching.
@@ -1194,10 +1218,13 @@ export class HyperliquidClient {
     }
 
     try {
+      // approveBuilderFee is a wallet-level authorization (not a vault action)
+      // and the SDK's `opts` parameter only carries an AbortSignal. Do not pass
+      // vaultParam here — the signature is { signal? }, not a vault wrapper.
       const response = await this.exchange.approveBuilderFee({
         builder: targetBuilder as `0x${string}`,
         maxFeeRate,
-      }, this.vaultParam);
+      });
       this.log('approveBuilderFee response:', response);
       return { status: 'ok', response };
     } catch (error) {
@@ -1242,7 +1269,18 @@ export class HyperliquidClient {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(body),
     });
-    const data = await response.json();
+    const data = await response.json() as Array<{
+      time: number;
+      hash: string;
+      delta: {
+        type: 'funding';
+        coin: string;
+        usdc: string;
+        szi: string;
+        fundingRate: string;
+        nSamples: number | null;
+      };
+    }>;
     this.log('userFunding response length:', data?.length);
     return data;
   }
@@ -1285,7 +1323,25 @@ export class HyperliquidClient {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(body),
     });
-    const data = await response.json();
+    const data = await response.json() as Array<{
+      coin: string;
+      px: string;
+      sz: string;
+      side: 'B' | 'A';
+      time: number;
+      startPosition: string;
+      dir: string;
+      closedPnl: string;
+      fee: string;
+      hash: string;
+      oid: number;
+      tid: number;
+      crossed: boolean;
+      feeToken: string;
+      twapId: number | null;
+      cloid: string | null;
+      builderFee: string | null;
+    }>;
     this.log('userFills response length:', data?.length);
     return data;
   }
@@ -1328,7 +1384,28 @@ export class HyperliquidClient {
         user: user ?? this.address,
       }),
     });
-    const data = await response.json();
+    const data = await response.json() as Array<{
+      order: {
+        coin: string;
+        side: string;
+        limitPx: string;
+        sz: string;
+        origSz: string;
+        oid: number;
+        timestamp: number;
+        orderType: string;
+        tif: string | null;
+        cloid: string | null;
+        triggerCondition: string;
+        triggerPx: string;
+        isTrigger: boolean;
+        isPositionTpsl: boolean;
+        reduceOnly: boolean;
+        children: unknown[];
+      };
+      status: string;
+      statusTimestamp: number;
+    }>;
     this.log('historicalOrders response length:', data?.length);
     return data;
   }
@@ -1374,7 +1451,30 @@ export class HyperliquidClient {
         oid: typeof oid === 'string' ? oid : oid,
       }),
     });
-    const data = await response.json();
+    const data = await response.json() as {
+      status: string;
+      order?: {
+        order: {
+          coin: string;
+          side: string;
+          limitPx: string;
+          sz: string;
+          origSz: string;
+          oid: number;
+          timestamp: number;
+          orderType: string;
+          tif: string | null;
+          cloid: string | null;
+          triggerCondition: string;
+          triggerPx: string;
+          isTrigger: boolean;
+          isPositionTpsl: boolean;
+          reduceOnly: boolean;
+        };
+        status: string;
+        statusTimestamp: number;
+      };
+    };
     this.log('orderStatus response:', JSON.stringify(data).slice(0, 500));
     return data;
   }
@@ -1409,7 +1509,20 @@ export class HyperliquidClient {
         user: user ?? this.address,
       }),
     });
-    const data = await response.json();
+    const data = await response.json() as {
+      dailyUserVlm: Array<{ date: string; exchange: string; userCross: string; userAdd: string }>;
+      feeSchedule: Record<string, unknown>;
+      userCrossRate: string;
+      userAddRate: string;
+      userSpotCrossRate: string;
+      userSpotAddRate: string;
+      activeReferralDiscount: string;
+      trial: unknown;
+      feeTrialEscrow: string;
+      nextTrialAvailableTimestamp: unknown;
+      stakingLink: { stakingUser: string; status: string } | null;
+      activeStakingDiscount: { basisPoints: number; discountRate: string } | null;
+    };
     this.log('userFees response:', JSON.stringify(data).slice(0, 500));
     return data;
   }
@@ -1448,7 +1561,18 @@ export class HyperliquidClient {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ type: 'candleSnapshot', req }),
     });
-    const data = await response.json();
+    const data = await response.json() as Array<{
+      t: number;
+      T: number;
+      s: string;
+      i: string;
+      o: string;
+      c: string;
+      h: string;
+      l: string;
+      v: string;
+      n: number;
+    }>;
     this.log('candleSnapshot response length:', data?.length);
     return data;
   }
@@ -1480,7 +1604,12 @@ export class HyperliquidClient {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(body),
     });
-    const data = await response.json();
+    const data = await response.json() as Array<{
+      coin: string;
+      fundingRate: string;
+      premium: string;
+      time: number;
+    }>;
     this.log('fundingHistory response length:', data?.length);
     return data;
   }
@@ -1510,7 +1639,15 @@ export class HyperliquidClient {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(body),
     });
-    const data = await response.json();
+    const data = await response.json() as Array<{
+      coin: string;
+      side: 'B' | 'A';
+      px: string;
+      sz: string;
+      time: number;
+      hash: string;
+      tid: number;
+    }>;
     this.log('recentTrades response length:', data?.length);
     return data;
   }
@@ -1537,7 +1674,12 @@ export class HyperliquidClient {
         user: user ?? this.address,
       }),
     });
-    const data = await response.json();
+    const data = await response.json() as {
+      cumVlm: string;
+      nRequestsUsed: number;
+      nRequestsCap: number;
+      nRequestsSurplus: number;
+    };
     this.log('userRateLimit response:', JSON.stringify(data));
     return data;
   }
@@ -2137,7 +2279,9 @@ export class HyperliquidClient {
     // Use the exact spot market key from spotMeta (e.g. "@230", "PURR/USDC").
     // On testnet the tradable asset id and displayed market key can diverge.
     const mids = await this.getAllMids();
-    let midStr = mids[spotCoinKey];
+    // Record<string, string> lookup returns `string` under TS defaults but
+    // is runtime-undefined when the key is absent — hence the explicit union.
+    let midStr: string | undefined = mids[spotCoinKey];
 
     // Fallback: allMids may omit spot pairs (especially on testnet).
     // Try spotMetaAndAssetCtxs which returns markPx directly.
@@ -2295,7 +2439,7 @@ export class HyperliquidClient {
     await this.getMetaAndAssetCtxs();
 
     if (leverage) {
-      await this.setLeverage(coin, leverage);
+      await this.updateLeverage(coin, leverage);
     }
 
     const assetIndex = this.getAssetIndex(coin);

package/scripts/core/types.ts

@@ -81,11 +81,18 @@ export interface CancelResponse {
 
 // ============ Market Data Types ============
 
+// Shape matches the upstream @nktkas/hyperliquid SDK response. Fields like
+// `onlyIsolated` and `premium` are absent-or-null in practice for some assets,
+// so they're modelled as optional / nullable. Index signature absorbs any
+// additional SDK fields we don't consume here (marginTableId, growthMode, …).
 export interface AssetMeta {
   name: string;
   szDecimals: number;
   maxLeverage: number;
-  onlyIsolated: boolean;
+  onlyIsolated?: boolean;
+  isDelisted?: boolean;
+  marginTableId?: number;
+  [key: string]: unknown;
 }
 
 export interface AssetCtx {
@@ -93,11 +100,13 @@ export interface AssetCtx {
   openInterest: string;
   prevDayPx: string;
   dayNtlVlm: string;
-  premium: string;
+  premium: string | null;
   oraclePx: string;
   markPx: string;
-  midPx?: string;
-  impactPxs?: [string, string];
+  midPx?: string | null;
+  impactPxs?: [string, string] | string[] | null;
+  dayBaseVlm?: string;
+  [key: string]: unknown;
 }
 
 export interface Meta {

package/scripts/core/ws.ts

@@ -51,6 +51,8 @@ export interface WsEventMap {
     time: number;
     closedPnl: string;
     fee: string;
+    /** Token the fee is denominated in. Spot buys typically pay fee in the base asset (e.g. "HYPE") rather than "USDC"; consumers must convert using `px` to get a USD value. */
+    feeToken: string;
     oid: number;
     crossed: boolean;
   };
@@ -245,6 +247,7 @@ export class WebSocketManager {
           time: fill.time,
           closedPnl: fill.closedPnl,
           fee: fill.fee,
+          feeToken: fill.feeToken,
           oid: fill.oid,
           crossed: fill.crossed,
         });

package/scripts/info/funding.ts

@@ -39,7 +39,7 @@ async function main() {
 
       const hourlyRate = parseFloat(ctx.funding);
       const annualizedRate = annualizeFundingRate(hourlyRate);
-      const premium = parseFloat(ctx.premium);
+      const premium = parseFloat(ctx.premium ?? '0');
       const openInterest = parseFloat(ctx.openInterest);
       const markPx = parseFloat(ctx.markPx);
 

package/scripts/operations/limit-order.ts

@@ -129,7 +129,7 @@ async function main() {
     console.log('\nResult');
     console.log('------');
 
-    if (response.status === 'ok' && response.response) {
+    if (response.status === 'ok' && response.response && typeof response.response !== 'string') {
       const statuses = response.response.data.statuses;
       for (const status of statuses) {
         if (status.filled) {

package/scripts/operations/twap-cancel.ts

@@ -49,11 +49,13 @@ async function main() {
 
     const response = await client.twapCancel(coin, twapId);
 
+    // SDK returns a success-only response shape; failures throw and are
+    // caught by the surrounding try/catch. `status` is the success literal.
     const status = response.response.data.status;
     if (typeof status === 'string' && status === 'success') {
       console.log(`\nTWAP order ${twapId} cancelled successfully.`);
-    } else if (typeof status === 'object' && 'error' in status) {
-      console.error(`\nFailed to cancel TWAP: ${status.error}`);
+    } else {
+      console.error(`\nUnexpected TWAP cancel response status: ${JSON.stringify(status)}`);
       process.exit(1);
     }
   } catch (error) {

package/scripts/operations/twap.ts

@@ -123,17 +123,15 @@ async function main() {
       leverage,
     );
 
+    // SDK's TwapOrderSuccessResponse excludes the error variant — the SDK
+    // throws on failure and the surrounding try/catch handles that. So
+    // `status` only ever carries `{ running }` here.
     const status = response.response.data.status;
-    if ('running' in status) {
-      console.log(`TWAP order placed successfully!`);
-      console.log(`TWAP ID: ${status.running.twapId}`);
-      console.log(`\nThe exchange is now executing your TWAP order over ${formatDuration(durationMinutes * 60)}.`);
-      console.log(`To cancel: openbroker twap-cancel --coin ${coin} --twap-id ${status.running.twapId}`);
-      console.log(`To check status: openbroker twap-status`);
-    } else if ('error' in status) {
-      console.error(`TWAP order failed: ${status.error}`);
-      process.exit(1);
-    }
+    console.log(`TWAP order placed successfully!`);
+    console.log(`TWAP ID: ${status.running.twapId}`);
+    console.log(`\nThe exchange is now executing your TWAP order over ${formatDuration(durationMinutes * 60)}.`);
+    console.log(`To cancel: openbroker twap-cancel --coin ${coin} --twap-id ${status.running.twapId}`);
+    console.log(`To check status: openbroker twap-status`);
   } catch (error) {
     console.error('Error:', error instanceof Error ? error.message : error);
     process.exit(1);

package/scripts/plugin/tools.ts

@@ -1385,24 +1385,21 @@ export function createTools(watcherOrCtx: PositionWatcher | null | ToolsContext)
           const midPrice = parseFloat(mids[coin]);
 
           const response = await client.twapOrder(coin, isBuy, size, durationMinutes, randomize, reduceOnly, leverage);
+          // SDK's TwapOrderSuccessResponse excludes errors; they'd throw and
+          // be caught below. Status is always `{ running }` on this branch.
           const status = response.response.data.status;
 
-          if ('running' in status) {
-            return json({
-              twapId: status.running.twapId,
-              coin,
-              side: isBuy ? 'buy' : 'sell',
-              size,
-              durationMinutes,
-              randomize,
-              reduceOnly,
-              estimatedNotional: midPrice ? midPrice * size : undefined,
-              midPrice: midPrice || undefined,
-            });
-          } else if ('error' in status) {
-            return error(status.error);
-          }
-          return error('Unexpected response');
+          return json({
+            twapId: status.running.twapId,
+            coin,
+            side: isBuy ? 'buy' : 'sell',
+            size,
+            durationMinutes,
+            randomize,
+            reduceOnly,
+            estimatedNotional: midPrice ? midPrice * size : undefined,
+            midPrice: midPrice || undefined,
+          });
         } catch (err) {
           return error(err instanceof Error ? err.message : String(err));
         }
@@ -1428,14 +1425,13 @@ export function createTools(watcherOrCtx: PositionWatcher | null | ToolsContext)
         try {
           const client = getClient();
           const response = await client.twapCancel(coin, twapId);
+          // SDK returns the success-only response; failures throw.
           const status = response.response.data.status;
 
           if (typeof status === 'string' && status === 'success') {
             return json({ cancelled: true, coin, twapId });
-          } else if (typeof status === 'object' && 'error' in status) {
-            return error(status.error);
           }
-          return error('Unexpected response');
+          return error(`Unexpected TWAP cancel status: ${JSON.stringify(status)}`);
         } catch (err) {
           return error(err instanceof Error ? err.message : String(err));
         }

package/scripts/setup/onboard.ts

@@ -387,8 +387,10 @@ Examples:
     return setupApiWallet();
   }
 
-  // Options 1 & 2: Master wallet flow
-  let privateKey: `0x${string}`;
+  // Options 1 & 2: Master wallet flow. Initialised in the branches below —
+  // the compiler can't prove the while-loop in option 2 assigns, so we use
+  // `| undefined` and narrow at use sites (`assertDefined`).
+  let privateKey: `0x${string}` | undefined;
 
   if (choice === '2') {
     // User has existing key
@@ -417,6 +419,10 @@ Examples:
     console.log('✅ New wallet created');
   }
 
+  if (!privateKey) {
+    throw new Error('Internal error: privateKey was not set by onboarding flow.');
+  }
+
   // Derive account from private key
   const account = privateKeyToAccount(privateKey);
   console.log(`\nWallet Address: ${account.address}\n`);