openbroker 1.0.33

package/scripts/core/client.ts

@@ -0,0 +1,844 @@
+// Hyperliquid Client for Open Broker
+// Uses @nktkas/hyperliquid SDK
+
+import { HttpTransport, InfoClient, ExchangeClient } from '@nktkas/hyperliquid';
+import { privateKeyToAccount, type PrivateKeyAccount } from 'viem/accounts';
+import type {
+  OpenBrokerConfig,
+  BuilderInfo,
+  OrderResponse,
+  CancelResponse,
+  MetaAndAssetCtxs,
+  ClearinghouseState,
+  OpenOrder,
+} from './types.js';
+import { loadConfig, isMainnet } from './config.js';
+import { roundPrice, roundSize } from './utils.js';
+
+export class HyperliquidClient {
+  private config: OpenBrokerConfig;
+  private account: PrivateKeyAccount;
+  private transport: HttpTransport;
+  private info: InfoClient;
+  private exchange: ExchangeClient;
+
+  private meta: MetaAndAssetCtxs | null = null;
+  private assetMap: Map<string, number> = new Map();
+  private szDecimalsMap: Map<string, number> = new Map();
+  public verbose: boolean = false;
+
+  constructor(config?: OpenBrokerConfig) {
+    this.config = config ?? loadConfig();
+    this.account = privateKeyToAccount(this.config.privateKey);
+    this.verbose = process.env.VERBOSE === '1' || process.env.VERBOSE === 'true';
+
+    // Initialize SDK clients
+    this.transport = new HttpTransport({ isMainnet: isMainnet() });
+    this.info = new InfoClient({ transport: this.transport });
+    this.exchange = new ExchangeClient({
+      transport: this.transport,
+      wallet: this.account,
+      isMainnet: isMainnet(),
+    });
+  }
+
+  private log(...args: unknown[]) {
+    if (this.verbose) {
+      console.log('[DEBUG]', ...args);
+    }
+  }
+
+  /** The address we're trading on behalf of (may be different from wallet if using API wallet) */
+  get address(): string {
+    return this.config.accountAddress;
+  }
+
+  /** The address of the signing wallet (derived from private key) */
+  get walletAddress(): string {
+    return this.config.walletAddress;
+  }
+
+  /** Whether we're using an API wallet (signing wallet differs from trading account) */
+  get isApiWallet(): boolean {
+    return this.config.isApiWallet;
+  }
+
+  get builderInfo(): BuilderInfo {
+    return {
+      b: this.config.builderAddress.toLowerCase(),
+      f: this.config.builderFee,
+    };
+  }
+
+  get builderAddress(): string {
+    return this.config.builderAddress;
+  }
+
+  get builderFeeBps(): number {
+    return this.config.builderFee / 10; // Convert from tenths of bps to bps
+  }
+
+  // ============ Market Data ============
+
+  async getMetaAndAssetCtxs(): Promise<MetaAndAssetCtxs> {
+    if (this.meta) return this.meta;
+
+    this.log('Fetching metaAndAssetCtxs...');
+    const response = await this.info.metaAndAssetCtxs();
+    this.log('metaAndAssetCtxs response:', JSON.stringify(response, null, 2).slice(0, 500) + '...');
+
+    this.meta = {
+      meta: { universe: response[0].universe },
+      assetCtxs: response[1],
+    };
+
+    // Build lookup maps
+    this.meta.meta.universe.forEach((asset, index) => {
+      this.assetMap.set(asset.name, index);
+      this.szDecimalsMap.set(asset.name, asset.szDecimals);
+    });
+
+    return this.meta;
+  }
+
+  async getAllMids(): Promise<Record<string, string>> {
+    this.log('Fetching allMids...');
+    const response = await this.info.allMids();
+    return response;
+  }
+
+  /**
+   * Get all perpetual DEXs (including HIP-3 builder-deployed markets)
+   * Returns array where index 0 is null (main dex), others are HIP-3 dexs
+   */
+  async getPerpDexs(): Promise<Array<{
+    name: string;
+    fullName: string;
+    deployer: string;
+  } | null>> {
+    this.log('Fetching perpDexs...');
+    const baseUrl = isMainnet()
+      ? 'https://api.hyperliquid.xyz'
+      : 'https://api.hyperliquid-testnet.xyz';
+
+    const response = await fetch(baseUrl + '/info', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'perpDexs' }),
+    });
+    const data = await response.json();
+    this.log('perpDexs response:', JSON.stringify(data).slice(0, 500));
+    return data;
+  }
+
+  /**
+   * Get all perp markets including HIP-3 dexs
+   * Returns array of [meta, assetCtxs] for each dex
+   */
+  async getAllPerpMetas(): Promise<Array<{
+    dexName: string | null;
+    meta: { universe: Array<{ name: string; szDecimals: number; maxLeverage: number; onlyIsolated?: boolean }> };
+    assetCtxs: Array<{
+      funding: string;
+      openInterest: string;
+      markPx: string;
+      midPx: string | null;
+      oraclePx: string;
+      prevDayPx: string;
+      dayNtlVlm: string;
+    }>;
+  }>> {
+    this.log('Fetching all perp markets...');
+    const baseUrl = isMainnet()
+      ? 'https://api.hyperliquid.xyz'
+      : 'https://api.hyperliquid-testnet.xyz';
+
+    const results: Array<{
+      dexName: string | null;
+      meta: { universe: Array<{ name: string; szDecimals: number; maxLeverage: number; onlyIsolated?: boolean }> };
+      assetCtxs: Array<{
+        funding: string;
+        openInterest: string;
+        markPx: string;
+        midPx: string | null;
+        oraclePx: string;
+        prevDayPx: string;
+        dayNtlVlm: string;
+      }>;
+    }> = [];
+
+    // Get main dex data (no dex parameter)
+    const mainResponse = await fetch(baseUrl + '/info', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'metaAndAssetCtxs' }),
+    });
+    const mainData = await mainResponse.json();
+    this.log('Main dex data fetched');
+
+    results.push({
+      dexName: null,
+      meta: { universe: mainData[0].universe },
+      assetCtxs: mainData[1],
+    });
+
+    // Get HIP-3 dex names
+    const dexs = await this.getPerpDexs();
+
+    // Fetch each HIP-3 dex by name
+    for (let i = 1; i < dexs.length; i++) {
+      const dex = dexs[i];
+      if (!dex) continue;
+
+      try {
+        const dexResponse = await fetch(baseUrl + '/info', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ type: 'metaAndAssetCtxs', dex: dex.name }),
+        });
+        const dexData = await dexResponse.json();
+
+        if (dexData && dexData[0]?.universe) {
+          this.log(`Fetched HIP-3 dex: ${dex.name} with ${dexData[0].universe.length} markets`);
+          results.push({
+            dexName: dex.name,
+            meta: { universe: dexData[0].universe },
+            assetCtxs: dexData[1] || [],
+          });
+        }
+      } catch (e) {
+        this.log(`Failed to fetch HIP-3 dex ${dex.name}:`, e);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get spot market metadata
+   */
+  async getSpotMeta(): Promise<{
+    tokens: Array<{
+      name: string;
+      szDecimals: number;
+      weiDecimals: number;
+      index: number;
+      tokenId: string;
+      isCanonical: boolean;
+      fullName: string | null;
+    }>;
+    universe: Array<{
+      name: string;
+      tokens: [number, number];
+      index: number;
+      isCanonical: boolean;
+    }>;
+  }> {
+    this.log('Fetching spotMeta...');
+    const baseUrl = isMainnet()
+      ? 'https://api.hyperliquid.xyz'
+      : 'https://api.hyperliquid-testnet.xyz';
+
+    const response = await fetch(baseUrl + '/info', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'spotMeta' }),
+    });
+    const data = await response.json();
+    this.log('spotMeta response:', JSON.stringify(data).slice(0, 500));
+    return data;
+  }
+
+  /**
+   * Get spot metadata with asset contexts (prices, volumes)
+   */
+  async getSpotMetaAndAssetCtxs(): Promise<{
+    meta: {
+      tokens: Array<{
+        name: string;
+        szDecimals: number;
+        weiDecimals: number;
+        index: number;
+        tokenId: string;
+        isCanonical: boolean;
+      }>;
+      universe: Array<{
+        name: string;
+        tokens: [number, number];
+        index: number;
+        isCanonical: boolean;
+      }>;
+    };
+    assetCtxs: Array<{
+      dayNtlVlm: string;
+      markPx: string;
+      midPx: string;
+      prevDayPx: string;
+    }>;
+  }> {
+    this.log('Fetching spotMetaAndAssetCtxs...');
+    const baseUrl = isMainnet()
+      ? 'https://api.hyperliquid.xyz'
+      : 'https://api.hyperliquid-testnet.xyz';
+
+    const response = await fetch(baseUrl + '/info', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'spotMetaAndAssetCtxs' }),
+    });
+    const data = await response.json();
+    this.log('spotMetaAndAssetCtxs response:', JSON.stringify(data).slice(0, 500));
+    return {
+      meta: data[0],
+      assetCtxs: data[1],
+    };
+  }
+
+  /**
+   * Get user's spot token balances
+   */
+  async getSpotBalances(user?: string): Promise<{
+    balances: Array<{
+      coin: string;
+      token: number;
+      hold: string;
+      total: string;
+      entryNtl: string;
+    }>;
+  }> {
+    this.log('Fetching spotClearinghouseState for:', user ?? this.address);
+    const baseUrl = isMainnet()
+      ? 'https://api.hyperliquid.xyz'
+      : 'https://api.hyperliquid-testnet.xyz';
+
+    const response = await fetch(baseUrl + '/info', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type: 'spotClearinghouseState',
+        user: user ?? this.address,
+      }),
+    });
+    const data = await response.json();
+    this.log('spotClearinghouseState response:', JSON.stringify(data).slice(0, 500));
+    return data;
+  }
+
+  /**
+   * Get token details by token ID
+   */
+  async getTokenDetails(tokenId: string): Promise<{
+    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('Fetching tokenDetails for:', tokenId);
+    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: 'tokenDetails',
+          tokenId,
+        }),
+      });
+      const data = await response.json();
+      this.log('tokenDetails response:', JSON.stringify(data).slice(0, 500));
+      return data;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get predicted funding rates across venues
+   */
+  async getPredictedFundings(): Promise<Array<[
+    string, // coin
+    Array<[string, { fundingRate: string; nextFundingTime: number }]> // venue funding rates
+  ]>> {
+    this.log('Fetching predictedFundings...');
+    const baseUrl = isMainnet()
+      ? 'https://api.hyperliquid.xyz'
+      : 'https://api.hyperliquid-testnet.xyz';
+
+    const response = await fetch(baseUrl + '/info', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'predictedFundings' }),
+    });
+    const data = await response.json();
+    this.log('predictedFundings response length:', data?.length);
+    return data;
+  }
+
+  /**
+   * Get L2 order book for an asset
+   * Returns best bid/ask and depth
+   */
+  async getL2Book(coin: string): Promise<{
+    bids: Array<{ px: string; sz: string; n: number }>;
+    asks: Array<{ px: string; sz: string; n: number }>;
+    bestBid: number;
+    bestAsk: number;
+    midPrice: number;
+    spread: number;
+    spreadBps: number;
+  }> {
+    this.log('Fetching l2Book for:', coin);
+    const response = await this.info.l2Book({ coin });
+
+    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;
+    const midPrice = (bestBid + bestAsk) / 2;
+    const spread = bestAsk - bestBid;
+    const spreadBps = midPrice > 0 ? (spread / midPrice) * 10000 : 0;
+
+    return {
+      bids,
+      asks,
+      bestBid,
+      bestAsk,
+      midPrice,
+      spread,
+      spreadBps,
+    };
+  }
+
+  getAssetIndex(coin: string): number {
+    const index = this.assetMap.get(coin);
+    if (index === undefined) {
+      throw new Error(`Unknown asset: ${coin}. Available: ${Array.from(this.assetMap.keys()).slice(0, 10).join(', ')}...`);
+    }
+    return index;
+  }
+
+  getSzDecimals(coin: string): number {
+    const decimals = this.szDecimalsMap.get(coin);
+    if (decimals === undefined) {
+      throw new Error(`Unknown asset: ${coin}`);
+    }
+    return decimals;
+  }
+
+  // ============ Account Info ============
+
+  /**
+   * Check if an address has sub-accounts (is a master account)
+   * Sub-accounts cannot approve builder fees - only master accounts can
+   */
+  async getSubAccounts(user?: string): Promise<Array<{ subAccountUser: string; name: string }>> {
+    this.log('Fetching subAccounts for:', user ?? this.address);
+    try {
+      const response = await this.info.subAccounts({ user: user ?? this.address });
+      if (!response) return [];
+      // Response is an array of sub-account objects
+      return response.map((sub: { subAccountUser: string; name: string }) => ({
+        subAccountUser: sub.subAccountUser,
+        name: sub.name,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Check the maximum builder fee approved for a user/builder pair
+   * Returns the max fee rate as a string (e.g., "0.1%") or null if not approved
+   */
+  async getMaxBuilderFee(user?: string, builder?: string): Promise<string | null> {
+    // IMPORTANT: Hyperliquid API requires lowercase addresses
+    const targetUser = (user ?? this.address).toLowerCase();
+    const targetBuilder = (builder ?? this.config.builderAddress).toLowerCase();
+
+    this.log('Fetching maxBuilderFee for:', targetUser, 'builder:', targetBuilder);
+
+    try {
+      const baseUrl = isMainnet()
+        ? 'https://api.hyperliquid.xyz'
+        : 'https://api.hyperliquid-testnet.xyz';
+
+      const response = await fetch(baseUrl + '/info', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'maxBuilderFee',
+          user: targetUser,
+          builder: targetBuilder,
+        }),
+      });
+      const data = await response.json();
+      this.log('maxBuilderFee response:', data);
+
+      // API returns a number (fee in tenths of bps) or 0/null if not approved
+      // e.g., 100 = 10 bps = 0.1%
+      if (data !== null && data !== undefined && data !== 0) {
+        // Convert from tenths of bps to percentage string
+        const bps = Number(data) / 10;
+        const pct = bps / 100;
+        return `${pct}%`;
+      }
+      return null;
+    } catch (error) {
+      this.log('maxBuilderFee error:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Approve a builder fee for the open-broker builder
+   * IMPORTANT: This must be signed by a MAIN wallet, not an API wallet or sub-account
+   *
+   * @param maxFeeRate - Max fee rate to approve (e.g., "0.01%" for 1 bps)
+   * @param builder - Builder address (defaults to open-broker builder)
+   */
+  async approveBuilderFee(
+    maxFeeRate: string = '0.1%',
+    builder?: string
+  ): Promise<{ status: 'ok' | 'err'; response?: unknown }> {
+    const targetBuilder = builder ?? this.config.builderAddress;
+
+    this.log('Approving builder fee:', maxFeeRate, 'for builder:', targetBuilder);
+
+    // Check if using API wallet - this won't work
+    if (this.isApiWallet) {
+      return {
+        status: 'err',
+        response: 'Cannot approve builder fee with API wallet. Must use main wallet private key.',
+      };
+    }
+
+    try {
+      const response = await this.exchange.approveBuilderFee({
+        builder: targetBuilder as `0x${string}`,
+        maxFeeRate,
+      });
+      this.log('approveBuilderFee response:', response);
+      return { status: 'ok', response };
+    } catch (error) {
+      this.log('approveBuilderFee error:', error);
+      return {
+        status: 'err',
+        response: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  async getUserState(user?: string): Promise<ClearinghouseState> {
+    this.log('Fetching clearinghouseState for:', user ?? this.address);
+    const response = await this.info.clearinghouseState({ user: user ?? this.address });
+    return response as ClearinghouseState;
+  }
+
+  async getOpenOrders(user?: string): Promise<OpenOrder[]> {
+    this.log('Fetching openOrders for:', user ?? this.address);
+    const response = await this.info.openOrders({ user: user ?? this.address });
+    return response as OpenOrder[];
+  }
+
+  // ============ Trading ============
+
+  async order(
+    coin: string,
+    isBuy: boolean,
+    size: number,
+    price: number,
+    orderType: { limit: { tif: 'Gtc' | 'Ioc' | 'Alo' } },
+    reduceOnly: boolean = false,
+    includeBuilder: boolean = true
+  ): Promise<OrderResponse> {
+    await this.getMetaAndAssetCtxs();
+
+    const assetIndex = this.getAssetIndex(coin);
+    const szDecimals = this.getSzDecimals(coin);
+
+    const orderWire = {
+      a: assetIndex,
+      b: isBuy,
+      p: roundPrice(price, szDecimals),
+      s: roundSize(size, szDecimals),
+      r: reduceOnly,
+      t: orderType,
+    };
+
+    this.log('Placing order:', JSON.stringify(orderWire, null, 2));
+
+    const orderRequest: {
+      orders: typeof orderWire[];
+      grouping: 'na';
+      builder?: BuilderInfo;
+    } = {
+      orders: [orderWire],
+      grouping: 'na',
+    };
+
+    // Add builder fee if configured
+    if (includeBuilder && this.config.builderAddress !== '0x0000000000000000000000000000000000000000') {
+      orderRequest.builder = this.builderInfo;
+      this.log('Including builder fee:', this.builderInfo);
+    }
+
+    try {
+      const response = await this.exchange.order(orderRequest);
+      this.log('Order response:', JSON.stringify(response, null, 2));
+      return response as unknown as OrderResponse;
+    } catch (error) {
+      this.log('Order error:', error);
+      // Return error in our format
+      return {
+        status: 'err',
+        response: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  async marketOrder(
+    coin: string,
+    isBuy: boolean,
+    size: number,
+    slippageBps?: number
+  ): Promise<OrderResponse> {
+    await this.getMetaAndAssetCtxs();
+
+    // Get current mid price
+    const mids = await this.getAllMids();
+    const midPrice = parseFloat(mids[coin]);
+    if (!midPrice) {
+      throw new Error(`No mid price for ${coin}. Check if the asset exists.`);
+    }
+
+    // Calculate slippage price
+    const slippage = (slippageBps ?? this.config.slippageBps) / 10000;
+    const limitPrice = isBuy
+      ? midPrice * (1 + slippage)
+      : midPrice * (1 - slippage);
+
+    this.log(`Market order: ${coin} ${isBuy ? 'BUY' : 'SELL'} ${size} @ ${limitPrice} (mid: ${midPrice}, slippage: ${slippage * 100}%)`);
+
+    return this.order(
+      coin,
+      isBuy,
+      size,
+      limitPrice,
+      { limit: { tif: 'Ioc' } },
+      false,
+      true
+    );
+  }
+
+  async limitOrder(
+    coin: string,
+    isBuy: boolean,
+    size: number,
+    price: number,
+    tif: 'Gtc' | 'Ioc' | 'Alo' = 'Gtc',
+    reduceOnly: boolean = false
+  ): Promise<OrderResponse> {
+    return this.order(
+      coin,
+      isBuy,
+      size,
+      price,
+      { limit: { tif } },
+      reduceOnly,
+      true
+    );
+  }
+
+  /**
+   * Place a trigger order (stop loss or take profit)
+   * @param coin - Asset to trade
+   * @param isBuy - True for buy, false for sell
+   * @param size - Order size
+   * @param triggerPrice - Price at which the order triggers
+   * @param limitPrice - Limit price for the order (use triggerPrice for market-like execution)
+   * @param tpsl - 'tp' for take profit, 'sl' for stop loss
+   * @param reduceOnly - Whether order is reduce-only (should be true for TP/SL)
+   */
+  async triggerOrder(
+    coin: string,
+    isBuy: boolean,
+    size: number,
+    triggerPrice: number,
+    limitPrice: number,
+    tpsl: 'tp' | 'sl',
+    reduceOnly: boolean = true
+  ): Promise<OrderResponse> {
+    await this.getMetaAndAssetCtxs();
+
+    const assetIndex = this.getAssetIndex(coin);
+    const szDecimals = this.getSzDecimals(coin);
+
+    // For trigger orders, we use the trigger order type
+    // isMarket: false means it becomes a limit order at limitPrice when triggered
+    // For stop loss, we typically want some slippage protection
+    const orderWire = {
+      a: assetIndex,
+      b: isBuy,
+      p: roundPrice(limitPrice, szDecimals),
+      s: roundSize(size, szDecimals),
+      r: reduceOnly,
+      t: {
+        trigger: {
+          triggerPx: roundPrice(triggerPrice, szDecimals),
+          isMarket: false,
+          tpsl,
+        },
+      },
+    };
+
+    this.log('Placing trigger order:', JSON.stringify(orderWire, null, 2));
+
+    const orderRequest: {
+      orders: typeof orderWire[];
+      grouping: 'na';
+      builder?: BuilderInfo;
+    } = {
+      orders: [orderWire],
+      grouping: 'na',
+    };
+
+    // Add builder fee if configured
+    if (this.config.builderAddress !== '0x0000000000000000000000000000000000000000') {
+      orderRequest.builder = this.builderInfo;
+      this.log('Including builder fee:', this.builderInfo);
+    }
+
+    try {
+      const response = await this.exchange.order(orderRequest);
+      this.log('Trigger order response:', JSON.stringify(response, null, 2));
+      return response as unknown as OrderResponse;
+    } catch (error) {
+      this.log('Trigger order error:', error);
+      return {
+        status: 'err',
+        response: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Place a stop loss order
+   */
+  async stopLoss(
+    coin: string,
+    isBuy: boolean,
+    size: number,
+    triggerPrice: number,
+    slippageBps: number = 100 // 1% slippage for SL execution
+  ): Promise<OrderResponse> {
+    // For stop loss, limit price should be worse than trigger to ensure fill
+    // Buy SL: limit above trigger, Sell SL: limit below trigger
+    const slippageMult = slippageBps / 10000;
+    const limitPrice = isBuy
+      ? triggerPrice * (1 + slippageMult)
+      : triggerPrice * (1 - slippageMult);
+
+    return this.triggerOrder(coin, isBuy, size, triggerPrice, limitPrice, 'sl', true);
+  }
+
+  /**
+   * Place a take profit order
+   */
+  async takeProfit(
+    coin: string,
+    isBuy: boolean,
+    size: number,
+    triggerPrice: number
+  ): Promise<OrderResponse> {
+    // For take profit, we can use the same price as trigger (it's a favorable price)
+    return this.triggerOrder(coin, isBuy, size, triggerPrice, triggerPrice, 'tp', true);
+  }
+
+  async cancel(coin: string, oid: number): Promise<CancelResponse> {
+    await this.getMetaAndAssetCtxs();
+
+    const assetIndex = this.getAssetIndex(coin);
+
+    this.log(`Cancelling order: ${coin} (asset ${assetIndex}) oid ${oid}`);
+
+    try {
+      const response = await this.exchange.cancel({
+        cancels: [{ a: assetIndex, o: oid }],
+      });
+      this.log('Cancel response:', JSON.stringify(response, null, 2));
+      return response as unknown as CancelResponse;
+    } catch (error) {
+      this.log('Cancel error:', error);
+      return {
+        status: 'err',
+        response: { type: 'cancel', data: { statuses: [error instanceof Error ? error.message : String(error)] } },
+      };
+    }
+  }
+
+  async cancelAll(coin?: string): Promise<CancelResponse[]> {
+    const orders = await this.getOpenOrders();
+    const results: CancelResponse[] = [];
+
+    for (const order of orders) {
+      if (coin && order.coin !== coin) continue;
+      const result = await this.cancel(order.coin, order.oid);
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  // ============ Leverage ============
+
+  async updateLeverage(
+    coin: string,
+    leverage: number,
+    isCross: boolean = true
+  ): Promise<unknown> {
+    await this.getMetaAndAssetCtxs();
+
+    const assetIndex = this.getAssetIndex(coin);
+
+    this.log(`Updating leverage: ${coin} (asset ${assetIndex}) to ${leverage}x ${isCross ? 'cross' : 'isolated'}`);
+
+    try {
+      const response = await this.exchange.updateLeverage({
+        asset: assetIndex,
+        isCross,
+        leverage,
+      });
+      this.log('Leverage response:', JSON.stringify(response, null, 2));
+      return response;
+    } catch (error) {
+      this.log('Leverage error:', error);
+      throw error;
+    }
+  }
+}
+
+// Singleton instance
+let clientInstance: HyperliquidClient | null = null;
+
+export function getClient(config?: OpenBrokerConfig): HyperliquidClient {
+  if (!clientInstance) {
+    clientInstance = new HyperliquidClient(config);
+  }
+  return clientInstance;
+}
+
+// Reset client (useful for testing)
+export function resetClient(): void {
+  clientInstance = null;
+}