@circuitorg/agent-sdk 1.2.3 → 1.3.0

package/index.d.ts

@@ -286,7 +286,7 @@ declare const AgentLogSchema: z.ZodObject<{
         reflect: "reflect";
         warning: "warning";
     }>;
-    shortMessage: z.ZodString;
+    message: z.ZodString;
 }, z.core.$strip>;
 type AgentLog = z.infer<typeof AgentLogSchema>;
 /**
@@ -601,14 +601,14 @@ declare const SwidgeExecuteResponseWrapperSchema: z.ZodObject<{
     success: z.ZodBoolean;
     data: z.ZodOptional<z.ZodObject<{
         status: z.ZodUnion<readonly [z.ZodLiteral<"success">, z.ZodLiteral<"failure">, z.ZodLiteral<"refund">, z.ZodLiteral<"delayed">]>;
-        in: z.ZodObject<{
+        in: z.ZodOptional<z.ZodObject<{
             network: z.ZodString;
             txs: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>;
-        out: z.ZodObject<{
+        }, z.core.$strip>>;
+        out: z.ZodOptional<z.ZodObject<{
             network: z.ZodString;
             txs: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>;
+        }, z.core.$strip>>;
         lastUpdated: z.ZodNumber;
         error: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -640,15 +640,12 @@ declare const PolymarketRedeemPositionsRequestSchema: z.ZodObject<{
 declare const PolymarketMarketOrderResponseSchema: z.ZodObject<{
     success: z.ZodBoolean;
     data: z.ZodOptional<z.ZodObject<{
-        success: z.ZodBoolean;
-        orderInfo: z.ZodObject<{
-            orderId: z.ZodString;
-            side: z.ZodString;
-            size: z.ZodString;
-            priceUsd: z.ZodString;
-            totalPriceUsd: z.ZodString;
-            txHashes: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>;
+        orderId: z.ZodString;
+        side: z.ZodString;
+        size: z.ZodString;
+        priceUsd: z.ZodString;
+        totalPriceUsd: z.ZodString;
+        txHashes: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
     errorMessage: z.ZodOptional<z.ZodString>;
@@ -701,6 +698,236 @@ type PolymarketRedeemPositionsRequest = z.infer<typeof PolymarketRedeemPositions
 type PolymarketMarketOrderResponse = z.infer<typeof PolymarketMarketOrderResponseSchema>;
 type PolymarketRedeemPositionsResponse = z.infer<typeof PolymarketRedeemPositionsResponseSchema>;
 
+/**
+ * Request to place an order on Hyperliquid
+ */
+declare const HyperliquidPlaceOrderRequestSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    side: z.ZodEnum<{
+        buy: "buy";
+        sell: "sell";
+    }>;
+    size: z.ZodNumber;
+    price: z.ZodNumber;
+    market: z.ZodEnum<{
+        perp: "perp";
+        spot: "spot";
+    }>;
+    type: z.ZodOptional<z.ZodEnum<{
+        market: "market";
+        limit: "limit";
+        stop: "stop";
+        take_profit: "take_profit";
+    }>>;
+    triggerPrice: z.ZodOptional<z.ZodNumber>;
+    reduceOnly: z.ZodOptional<z.ZodBoolean>;
+    postOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Request to transfer between spot and perp accounts on Hyperliquid
+ */
+declare const HyperliquidTransferRequestSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    toPerp: z.ZodBoolean;
+}, z.core.$strip>;
+declare const HyperliquidPlaceOrderResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodObject<{
+        orderId: z.ZodString;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            buy: "buy";
+            sell: "sell";
+        }>;
+        price: z.ZodNumber;
+        size: z.ZodNumber;
+        filled: z.ZodNumber;
+        status: z.ZodString;
+        market: z.ZodEnum<{
+            perp: "perp";
+            spot: "spot";
+        }>;
+        clientOrderId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidOrderResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodObject<{
+        orderId: z.ZodString;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            buy: "buy";
+            sell: "sell";
+        }>;
+        price: z.ZodNumber;
+        size: z.ZodNumber;
+        filled: z.ZodNumber;
+        status: z.ZodString;
+        market: z.ZodEnum<{
+            perp: "perp";
+            spot: "spot";
+        }>;
+        clientOrderId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidDeleteOrderResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodUndefined>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidBalancesResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodObject<{
+        perp: z.ZodObject<{
+            accountValue: z.ZodString;
+            totalMarginUsed: z.ZodString;
+            withdrawable: z.ZodString;
+        }, z.core.$strip>;
+        spot: z.ZodArray<z.ZodObject<{
+            coin: z.ZodString;
+            total: z.ZodString;
+            hold: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidPositionsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            long: "long";
+            short: "short";
+        }>;
+        size: z.ZodString;
+        entryPrice: z.ZodString;
+        markPrice: z.ZodString;
+        liquidationPrice: z.ZodNullable<z.ZodString>;
+        unrealizedPnl: z.ZodString;
+        leverage: z.ZodString;
+        marginUsed: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidOpenOrdersResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        orderId: z.ZodString;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            buy: "buy";
+            sell: "sell";
+        }>;
+        price: z.ZodNumber;
+        size: z.ZodNumber;
+        filled: z.ZodNumber;
+        status: z.ZodString;
+        market: z.ZodEnum<{
+            perp: "perp";
+            spot: "spot";
+        }>;
+        clientOrderId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidOrderFillsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        orderId: z.ZodString;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            buy: "buy";
+            sell: "sell";
+        }>;
+        price: z.ZodString;
+        size: z.ZodString;
+        fee: z.ZodString;
+        timestamp: z.ZodNumber;
+        isMaker: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidHistoricalOrdersResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        orderId: z.ZodString;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            buy: "buy";
+            sell: "sell";
+        }>;
+        price: z.ZodNumber;
+        size: z.ZodNumber;
+        filled: z.ZodNumber;
+        status: z.ZodEnum<{
+            filled: "filled";
+            open: "open";
+            canceled: "canceled";
+            triggered: "triggered";
+            rejected: "rejected";
+            marginCanceled: "marginCanceled";
+            liquidatedCanceled: "liquidatedCanceled";
+        }>;
+        market: z.ZodEnum<{
+            perp: "perp";
+            spot: "spot";
+        }>;
+        timestamp: z.ZodNumber;
+        statusTimestamp: z.ZodNumber;
+        orderType: z.ZodEnum<{
+            Market: "Market";
+            Limit: "Limit";
+            "Stop Market": "Stop Market";
+            "Stop Limit": "Stop Limit";
+            "Take Profit Market": "Take Profit Market";
+            "Take Profit Limit": "Take Profit Limit";
+        }>;
+        clientOrderId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidTransferResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodUndefined>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const HyperliquidLiquidationsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodNumber;
+        liquidatedPositions: z.ZodArray<z.ZodObject<{
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                long: "long";
+                short: "short";
+            }>;
+            size: z.ZodString;
+        }, z.core.$strip>>;
+        totalNotional: z.ZodString;
+        accountValue: z.ZodString;
+        leverageType: z.ZodEnum<{
+            Cross: "Cross";
+            Isolated: "Isolated";
+        }>;
+        txHash: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type HyperliquidPlaceOrderRequest = z.infer<typeof HyperliquidPlaceOrderRequestSchema>;
+type HyperliquidTransferRequest = z.infer<typeof HyperliquidTransferRequestSchema>;
+type HyperliquidPlaceOrderResponse = z.infer<typeof HyperliquidPlaceOrderResponseSchema>;
+type HyperliquidOrderResponse = z.infer<typeof HyperliquidOrderResponseSchema>;
+type HyperliquidDeleteOrderResponse = z.infer<typeof HyperliquidDeleteOrderResponseSchema>;
+type HyperliquidBalancesResponse = z.infer<typeof HyperliquidBalancesResponseSchema>;
+type HyperliquidPositionsResponse = z.infer<typeof HyperliquidPositionsResponseSchema>;
+type HyperliquidOpenOrdersResponse = z.infer<typeof HyperliquidOpenOrdersResponseSchema>;
+type HyperliquidOrderFillsResponse = z.infer<typeof HyperliquidOrderFillsResponseSchema>;
+type HyperliquidHistoricalOrdersResponse = z.infer<typeof HyperliquidHistoricalOrdersResponseSchema>;
+type HyperliquidTransferResponse = z.infer<typeof HyperliquidTransferResponseSchema>;
+type HyperliquidLiquidationsResponse = z.infer<typeof HyperliquidLiquidationsResponseSchema>;
+
 /**
  * Memory type definitions for agent session storage
  *
@@ -804,7 +1031,7 @@ type MemoryListResponse = z.infer<typeof MemoryListResponseSchema>;
  *   sessionId: 12345,
  * });
  *
- * await sdk.sendLog({ type: "observe", shortMessage: "Starting" });
+ * await sdk.sendLog({ type: "observe", message: "Starting" });
  * const tx = await sdk.signAndSend({
  *   network: "ethereum:42161",
  *   request: {
@@ -830,6 +1057,17 @@ declare class AgentSdk {
      * ```
      */
     constructor(config: SDKConfig);
+    /**
+     * @internal
+     *
+     * **DO NOT USE - WILL BREAK YOUR AGENTS**
+     *
+     * ⚠️ **WARNING**: This method will cause issues and break your agents.
+     * Do not use this method.
+     *
+     * @param baseUrl - New base URL to use for API requests
+     */
+    setBaseUrl(baseUrl: string): void;
     /**
      * Internal method to send logs to the backend.
      * Used by AgentContext.log() method.
@@ -1044,7 +1282,7 @@ declare class AgentSdk {
          * @returns SwidgeExecuteResponse or array of responses (matching input type) with transaction status and details
          *   - `success` (boolean): Whether the execution was successful
          *   - `data` (SwidgeExecuteData | undefined): Execution result containing:
-         *     - `status`: "success" | "failure" | "refund" | "delayed" - Final transaction status
+         *     - `status`: "success" | "failure" | "refund" | "delayed" | "error" - Final transaction status
          *     - `in`: Source transaction details with txs array (transaction hashes)
          *     - `out`: Destination transaction details with txs array (transaction hashes)
          *     - Additional metadata about the swap/bridge operation
@@ -1259,15 +1497,13 @@ declare class AgentSdk {
              *
              * **Output**: `PolymarketMarketOrderResponse`
              *   - `success` (boolean): Whether the operation was successful
-             *   - `data` (PolymarketMarketOrderData | undefined): Market order data (only present on success)
-             *     - `success` (boolean): Whether the order was successfully submitted
-             *     - `orderInfo` (PolymarketOrderInfo): Order information with transaction details
-             *       - `orderId` (string): Unique order identifier
-             *       - `side` (string): Order side ("BUY" or "SELL")
-             *       - `size` (string): Order size
-             *       - `priceUsd` (string): Price per share in USD
-             *       - `totalPriceUsd` (string): Total order value in USD
-             *       - `txHashes` (string[]): List of transaction hashes
+             *   - `data` (PolymarketOrderInfo | undefined): Order information (only present on success)
+             *     - `orderId` (string): Unique order identifier
+             *     - `side` (string): Order side ("BUY" or "SELL")
+             *     - `size` (string): Order size
+             *     - `priceUsd` (string): Price per share in USD
+             *     - `totalPriceUsd` (string): Total order value in USD
+             *     - `txHashes` (string[]): List of transaction hashes
              *   - `error` (string | undefined): Error message (only present on failure)
              *   - `errorDetails` (object | undefined): Detailed error info
              *
@@ -1296,9 +1532,8 @@ declare class AgentSdk {
              * });
              *
              * if (buyResult.success && buyResult.data) {
-             *   console.log(`Order Success: ${buyResult.data.success}`);
-             *   console.log(`Order ID: ${buyResult.data.orderInfo.orderId}`);
-             *   console.log(`Total Price: $${buyResult.data.orderInfo.totalPriceUsd}`);
+             *   console.log(`Order ID: ${buyResult.data.orderId}`);
+             *   console.log(`Total Price: $${buyResult.data.totalPriceUsd}`);
              * } else {
              *   console.error(`Error: ${buyResult.error}`);
              * }
@@ -1309,17 +1544,13 @@ declare class AgentSdk {
              * {
              *   "success": true,
              *   "data": {
-             *     "success": true,
-             *     "orderInfo": {
-             *       "orderId": "abc123",
-             *       "side": "BUY",
-             *       "size": "10.0",
-             *       "priceUsd": "0.52",
-             *       "totalPriceUsd": "5.20",
-             *       "txHashes": ["0xabc..."]
-             *     }
-             *   },
-             *   "error": undefined
+             *     "orderId": "abc123",
+             *     "side": "BUY",
+             *     "size": "10.0",
+             *     "priceUsd": "0.52",
+             *     "totalPriceUsd": "5.20",
+             *     "txHashes": ["0xabc..."]
+             *   }
              * }
              * ```
              *
@@ -1327,7 +1558,6 @@ declare class AgentSdk {
              * ```json
              * {
              *   "success": false,
-             *   "data": undefined,
              *   "error": "Could not get order",
              *   "errorDetails": { "message": "Invalid request", "status": 400 }
              * }
@@ -1432,6 +1662,400 @@ declare class AgentSdk {
              */
             redeemPositions: (request?: PolymarketRedeemPositionsRequest) => Promise<PolymarketRedeemPositionsResponse>;
         };
+        /**
+         * 🔄 Hyperliquid: Trade perpetuals on Hyperliquid DEX
+         *
+         * Access perpetuals trading operations including orders, positions, and transfers.
+         * All operations are policy-checked and signed automatically.
+         */
+        hyperliquid: {
+            /**
+             * Place an order on Hyperliquid
+             *
+             * Submit a market, limit, stop, or take-profit order for perpetuals or spot trading.
+             *
+             * **Input**: `HyperliquidPlaceOrderRequest`
+             *   - `symbol` (string): Trading pair symbol (e.g., "BTC-USD")
+             *   - `side` ("buy" | "sell"): Order side
+             *   - `size` (number): Order size
+             *   - `price` (number): Order price (for market orders, acts as slippage limit)
+             *   - `market` ("perp" | "spot"): Market type
+             *   - `type` (string, optional): Order type ("limit", "market", "stop", "take_profit")
+             *   - `triggerPrice` (number, optional): Trigger price for stop/take-profit orders
+             *   - `reduceOnly` (boolean, optional): Whether this is a reduce-only order
+             *   - `postOnly` (boolean, optional): Whether this is a post-only order
+             *
+             * **Output**: `HyperliquidPlaceOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidOrderInfo | undefined): Order information (only present on success)
+             *     - `data.orderId` (string): Order ID
+             *     - `data.symbol` (string): Trading pair symbol
+             *     - `data.side` ("buy" | "sell"): Order side
+             *     - `data.price` (number): Order price
+             *     - `data.size` (number): Order size
+             *     - `data.filled` (number): Filled amount
+             *     - `data.status` (string): Order status
+             *     - `data.market` ("perp" | "spot"): Market type
+             *     - `data.clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @param request - Order parameters
+             * @returns Promise resolving to HyperliquidPlaceOrderResponse
+             *
+             * @example
+             * ```ts
+             * // Market order
+             * const result = await sdk.platforms.hyperliquid.placeOrder({
+             *   symbol: "BTC-USD",
+             *   side: "buy",
+             *   size: 0.0001,
+             *   price: 110000,
+             *   market: "perp",
+             *   type: "market",
+             * });
+             *
+             * // Limit order
+             * const result = await sdk.platforms.hyperliquid.placeOrder({
+             *   symbol: "BTC-USD",
+             *   side: "buy",
+             *   size: 0.0001,
+             *   price: 100000,
+             *   market: "perp",
+             *   type: "limit",
+             * });
+             *
+             * if (result.success && result.data) {
+             *   console.log(`Order placed: ${result.data.orderId}`);
+             *   console.log(`Status: ${result.data.status}`);
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            placeOrder: (request: HyperliquidPlaceOrderRequest) => Promise<HyperliquidPlaceOrderResponse>;
+            /**
+             * Get order information by order ID
+             *
+             * Retrieve details for a specific order including status, filled amount, and price.
+             *
+             * **Input**: `orderId` (string) - Unique order identifier
+             *
+             * **Output**: `HyperliquidOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidOrderInfo | undefined): Order details (only present on success)
+             *     - `data.orderId` (string): Order ID
+             *     - `data.symbol` (string): Trading pair symbol
+             *     - `data.side` ("buy" | "sell"): Order side
+             *     - `data.price` (number): Order price
+             *     - `data.size` (number): Order size
+             *     - `data.filled` (number): Filled amount
+             *     - `data.status` (string): Order status
+             *     - `data.market` ("perp" | "spot"): Market type
+             *     - `data.clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @param orderId - Order ID to query
+             * @returns Promise resolving to HyperliquidOrderResponse
+             *
+             * @example
+             * ```ts
+             * const result = await sdk.platforms.hyperliquid.order("12345");
+             * if (result.success && result.data) {
+             *   console.log(`Order ${result.data.orderId}: ${result.data.status}`);
+             *   console.log(`Filled: ${result.data.filled}/${result.data.size}`);
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            order: (orderId: string) => Promise<HyperliquidOrderResponse>;
+            /**
+             * Cancel an order
+             *
+             * Cancel an open order by order ID and symbol.
+             *
+             * **Input**:
+             *   - `orderId` (string): Order ID to cancel
+             *   - `symbol` (string): Trading symbol
+             *
+             * **Output**: `HyperliquidDeleteOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * Note: This operation returns no data on success (void response).
+             *
+             * @param orderId - Order ID to cancel
+             * @param symbol - Trading symbol
+             * @returns Promise resolving to HyperliquidDeleteOrderResponse
+             *
+             * @example
+             * ```ts
+             * const result = await sdk.platforms.hyperliquid.deleteOrder("12345", "BTC-USD");
+             * if (result.success) {
+             *   console.log("Order cancelled successfully");
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            deleteOrder: (orderId: string, symbol: string) => Promise<HyperliquidDeleteOrderResponse>;
+            /**
+             * Get account balances
+             *
+             * Retrieve perp and spot account balances.
+             *
+             * **Output**: `HyperliquidBalancesResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidBalances | undefined): Balance data (only present on success)
+             *     - `data.perp` (HyperliquidPerpBalance): Perp account balance
+             *       - `data.perp.accountValue` (string): Total account value
+             *       - `data.perp.totalMarginUsed` (string): Total margin used
+             *       - `data.perp.withdrawable` (string): Withdrawable amount
+             *     - `data.spot` (HyperliquidSpotBalance[]): Spot token balances
+             *       - `data.spot[].coin` (string): Token symbol
+             *       - `data.spot[].total` (string): Total balance
+             *       - `data.spot[].hold` (string): Amount on hold
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidBalancesResponse
+             *
+             * @example
+             * ```ts
+             * const result = await sdk.platforms.hyperliquid.balances();
+             * if (result.success && result.data) {
+             *   console.log(`Account value: ${result.data.perp.accountValue}`);
+             *   console.log(`Withdrawable: ${result.data.perp.withdrawable}`);
+             *   for (const balance of result.data.spot) {
+             *     console.log(`${balance.coin}: ${balance.total}`);
+             *   }
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            balances: () => Promise<HyperliquidBalancesResponse>;
+            /**
+             * Get open positions
+             *
+             * Retrieve all open perpetual positions with PnL and position details.
+             *
+             * **Output**: `HyperliquidPositionsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidPosition[] | undefined): Array of open positions (only present on success)
+             *     - `data[].symbol` (string): Trading pair symbol (e.g., "BTC-USD")
+             *     - `data[].side` ("long" | "short"): Position side
+             *     - `data[].size` (string): Position size
+             *     - `data[].entryPrice` (string): Average entry price
+             *     - `data[].markPrice` (string): Current mark price
+             *     - `data[].liquidationPrice` (string | null): Liquidation price (null if no risk)
+             *     - `data[].unrealizedPnl` (string): Unrealized profit/loss
+             *     - `data[].leverage` (string): Current leverage
+             *     - `data[].marginUsed` (string): Margin allocated to position
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidPositionsResponse
+             *
+             * @example
+             * ```ts
+             * const result = await sdk.platforms.hyperliquid.positions();
+             * if (result.success && result.data) {
+             *   for (const pos of result.data) {
+             *     console.log(`${pos.symbol}: ${pos.side} ${pos.size}`);
+             *     console.log(`Entry: ${pos.entryPrice}, Mark: ${pos.markPrice}`);
+             *     console.log(`Unrealized PnL: ${pos.unrealizedPnl}`);
+             *   }
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            positions: () => Promise<HyperliquidPositionsResponse>;
+            /**
+             * Get open orders
+             *
+             * Retrieve all currently open orders.
+             *
+             * **Output**: `HyperliquidOpenOrdersResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidOrderInfo[] | undefined): Array of open orders (only present on success)
+             *     - `data[].orderId` (string): Order ID
+             *     - `data[].symbol` (string): Trading pair symbol
+             *     - `data[].side` ("buy" | "sell"): Order side
+             *     - `data[].price` (number): Order price
+             *     - `data[].size` (number): Order size
+             *     - `data[].filled` (number): Filled amount
+             *     - `data[].status` (string): Order status
+             *     - `data[].market` ("perp" | "spot"): Market type
+             *     - `data[].clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidOpenOrdersResponse
+             *
+             * @example
+             * ```ts
+             * const result = await sdk.platforms.hyperliquid.openOrders();
+             * if (result.success && result.data) {
+             *   console.log(`You have ${result.data.length} open orders`);
+             *   for (const order of result.data) {
+             *     console.log(`${order.symbol}: ${order.side} ${order.size} @ ${order.price}`);
+             *   }
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            openOrders: () => Promise<HyperliquidOpenOrdersResponse>;
+            /**
+             * Get order fill history
+             *
+             * Retrieve order fill history including partial and complete fills.
+             *
+             * **Output**: `HyperliquidOrderFillsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidFill[] | undefined): Array of order fills (only present on success)
+             *     - `data[].orderId` (string): Order ID
+             *     - `data[].symbol` (string): Trading pair symbol
+             *     - `data[].side` ("buy" | "sell"): Fill side
+             *     - `data[].price` (string): Fill price
+             *     - `data[].size` (string): Fill size
+             *     - `data[].fee` (string): Trading fee paid
+             *     - `data[].timestamp` (number): Fill timestamp in milliseconds
+             *     - `data[].isMaker` (boolean): True if maker, false if taker
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidOrderFillsResponse
+             *
+             * @example
+             * ```ts
+             * const result = await sdk.platforms.hyperliquid.orderFills();
+             * if (result.success && result.data) {
+             *   console.log(`Total fills: ${result.data.length}`);
+             *   for (const fill of result.data) {
+             *     const fillType = fill.isMaker ? "maker" : "taker";
+             *     console.log(`${fill.symbol}: ${fill.size} @ ${fill.price} (${fillType}, fee: ${fill.fee})`);
+             *   }
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            orderFills: () => Promise<HyperliquidOrderFillsResponse>;
+            /**
+             * Get historical orders
+             *
+             * Retrieve order history including filled, cancelled, and expired orders.
+             *
+             * **Output**: `HyperliquidHistoricalOrdersResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidHistoricalOrder[] | undefined): Array of historical orders (only present on success)
+             *     - `data[].orderId` (string): Order ID
+             *     - `data[].symbol` (string): Trading pair symbol
+             *     - `data[].side` ("buy" | "sell"): Order side
+             *     - `data[].price` (number): Order price
+             *     - `data[].size` (number): Order size
+             *     - `data[].filled` (number): Filled amount
+             *     - `data[].status` ("open" | "filled" | "canceled" | "triggered" | "rejected" | "marginCanceled" | "liquidatedCanceled"): Order status
+             *     - `data[].market` ("perp" | "spot"): Market type
+             *     - `data[].timestamp` (number): Order creation timestamp in milliseconds
+             *     - `data[].statusTimestamp` (number): Status update timestamp in milliseconds
+             *     - `data[].orderType` ("Market" | "Limit" | "Stop Market" | "Stop Limit" | "Take Profit Market" | "Take Profit Limit"): Order type
+             *     - `data[].clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidHistoricalOrdersResponse
+             *
+             * @example
+             * ```ts
+             * const result = await sdk.platforms.hyperliquid.orders();
+             * if (result.success && result.data) {
+             *   console.log(`Order history: ${result.data.length} orders`);
+             *   const filled = result.data.filter(o => o.status === "filled");
+             *   console.log(`Filled orders: ${filled.length}`);
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            orders: () => Promise<HyperliquidHistoricalOrdersResponse>;
+            /**
+             * Transfer between spot and perp accounts
+             *
+             * Move funds between your spot wallet and perpetuals trading account.
+             *
+             * **Input**: `HyperliquidTransferRequest`
+             *   - `amount` (number): Amount to transfer
+             *   - `toPerp` (boolean): True to transfer to perp account, False to transfer to spot
+             *
+             * **Output**: `HyperliquidTransferResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * Note: This operation returns no data on success (void response).
+             *
+             * @param request - Transfer parameters
+             * @returns Promise resolving to HyperliquidTransferResponse
+             *
+             * @example
+             * ```ts
+             * // Transfer 1000 USDC to perp account
+             * const result = await sdk.platforms.hyperliquid.transfer({
+             *   amount: 1000,
+             *   toPerp: true
+             * });
+             *
+             * if (result.success) {
+             *   console.log("Transfer completed successfully");
+             * } else {
+             *   console.error(`Error: ${result.error}`);
+             * }
+             * ```
+             */
+            transfer: (request: HyperliquidTransferRequest) => Promise<HyperliquidTransferResponse>;
+            /**
+             * Get liquidation events
+             *
+             * Retrieve liquidation events for the account, optionally filtered by start time.
+             *
+             * **Input**: `startTime` (number, optional) - Unix timestamp in milliseconds to filter liquidations from
+             *
+             * **Output**: `HyperliquidLiquidationsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidLiquidation[] | undefined): Array of liquidation events (only present on success)
+             *     - `data[].timestamp` (number): Liquidation timestamp in milliseconds
+             *     - `data[].liquidatedPositions` (HyperliquidLiquidatedPosition[]): Liquidated positions
+             *       - `data[].liquidatedPositions[].symbol` (string): Position symbol (e.g., "BTC-USD")
+             *       - `data[].liquidatedPositions[].side` ("long" | "short"): Position side
+             *       - `data[].liquidatedPositions[].size` (string): Position size that was liquidated
+             *     - `data[].totalNotional` (string): Total notional value liquidated
+             *     - `data[].accountValue` (string): Account value at liquidation
+             *     - `data[].leverageType` ("Cross" | "Isolated"): Leverage type
+             *     - `data[].txHash` (string): Transaction hash
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @param startTime - Optional start time for filtering (Unix timestamp in milliseconds)
+             * @returns Promise resolving to HyperliquidLiquidationsResponse
+             *
+             * @example
+             * ```ts
+             * // Get all liquidations (defaults to last 30 days)
+             * const all = await sdk.platforms.hyperliquid.liquidations();
+             *
+             * // Get liquidations from last 24h
+             * const yesterday = Date.now() - (24 * 60 * 60 * 1000);
+             * const recent = await sdk.platforms.hyperliquid.liquidations(yesterday);
+             *
+             * if (recent.success && recent.data) {
+             *   console.log(`Liquidations in last 24h: ${recent.data.length}`);
+             *   for (const liq of recent.data) {
+             *     console.log(`Liquidated ${liq.liquidatedPositions.length} positions`);
+             *   }
+             * } else {
+             *   console.error(`Error: ${recent.error}`);
+             * }
+             * ```
+             */
+            liquidations: (startTime?: number) => Promise<HyperliquidLiquidationsResponse>;
+        };
     };
     /**
      * Handle EVM transaction signing and broadcasting
@@ -1463,6 +2087,46 @@ declare class AgentSdk {
     private handleSwidgeExecute;
     private handlePolymarketMarketOrder;
     private handlePolymarketRedeemPositions;
+    /**
+     * Handle Hyperliquid place order requests
+     */
+    private handleHyperliquidPlaceOrder;
+    /**
+     * Handle Hyperliquid get order requests
+     */
+    private handleHyperliquidGetOrder;
+    /**
+     * Handle Hyperliquid delete order requests
+     */
+    private handleHyperliquidDeleteOrder;
+    /**
+     * Handle Hyperliquid get balances requests
+     */
+    private handleHyperliquidGetBalances;
+    /**
+     * Handle Hyperliquid get positions requests
+     */
+    private handleHyperliquidGetPositions;
+    /**
+     * Handle Hyperliquid get open orders requests
+     */
+    private handleHyperliquidGetOpenOrders;
+    /**
+     * Handle Hyperliquid get order fills requests
+     */
+    private handleHyperliquidGetOrderFills;
+    /**
+     * Handle Hyperliquid get historical orders requests
+     */
+    private handleHyperliquidGetHistoricalOrders;
+    /**
+     * Handle Hyperliquid transfer requests
+     */
+    private handleHyperliquidTransfer;
+    /**
+     * Handle Hyperliquid get liquidations requests
+     */
+    private handleHyperliquidGetLiquidations;
     /**
      * Handle memory set requests
      */
@@ -1703,7 +2367,7 @@ interface CurrentPosition {
  * - **Request metadata**: `sessionId`, `sessionWalletAddress`, `currentPositions`
  * - **Core methods**: `log()`, `signAndSend()`, `signMessage()`
  * - **Memory operations**: `memory.set()`, `memory.get()`, `memory.delete()`, `memory.list()`
- * - **Platform integrations**: `platforms.polymarket.*` for prediction market trading
+ * - **Platform integrations**: `platforms.polymarket.*` for prediction market trading, `platforms.hyperliquid.*` for perpetuals trading
  * - **Cross-chain swaps**: `swidge.quote()`, `swidge.execute()`
  *
  * The agent developer's execution and stop functions receive this object:
@@ -1768,10 +2432,14 @@ interface CurrentPosition {
  * @property memory.delete - Delete a key from session memory
  * @property memory.list - List all keys in session memory
  *
- * @property platforms - Platform integrations (Polymarket, etc.)
+ * @property platforms - Platform integrations (Polymarket, Hyperliquid, etc.)
  * @property platforms.polymarket - Prediction market trading operations
  * @property platforms.polymarket.marketOrder - Execute a buy or sell market order on Polymarket
  * @property platforms.polymarket.redeemPositions - Redeem settled positions and claim winnings
+ * @property platforms.hyperliquid - Perpetuals trading operations on Hyperliquid DEX
+ * @property platforms.hyperliquid.placeOrder - Place an order on Hyperliquid
+ * @property platforms.hyperliquid.balances - Get account balances
+ * @property platforms.hyperliquid.positions - Get open positions
  *
  * @property swidge - Cross-chain swap and bridge operations
  * @property swidge.quote - Get a quote for swapping tokens between networks
@@ -1817,6 +2485,17 @@ declare class AgentContext {
         baseUrl?: string;
         authorizationHeader?: string;
     });
+    /**
+     * @internal
+     *
+     * **DO NOT USE - WILL BREAK YOUR AGENTS**
+     *
+     * ⚠️ **WARNING**: This method will cause issues and break your agents.
+     * Do not use this method.
+     *
+     * @param baseUrl - New base URL to use for API requests
+     */
+    setBaseUrl(baseUrl: string): void;
     /**
      * Unified logging method that handles console output and backend messaging.
      *
@@ -2113,7 +2792,7 @@ declare class AgentContext {
      * Access platform integrations for trading and DeFi operations.
      *
      * Platform integrations provide seamless access to external services like
-     * prediction markets, lending protocols, and more.
+     * prediction markets, perpetuals trading, and more.
      */
     readonly platforms: {
         /**
@@ -2205,6 +2884,399 @@ declare class AgentContext {
              */
             redeemPositions: (request?: PolymarketRedeemPositionsRequest) => Promise<PolymarketRedeemPositionsResponse>;
         };
+        /**
+         * Access Hyperliquid perpetuals trading operations.
+         *
+         * Trade perpetual contracts on Hyperliquid DEX using your session wallet.
+         */
+        hyperliquid: {
+            /**
+             * Place an order on Hyperliquid
+             *
+             * Submit a market, limit, stop, or take-profit order for perpetuals or spot trading.
+             *
+             * **Input**: `HyperliquidPlaceOrderRequest`
+             *   - `symbol` (string): Trading pair symbol (e.g., "BTC-USD")
+             *   - `side` ("buy" | "sell"): Order side
+             *   - `size` (number): Order size
+             *   - `price` (number): Order price (for market orders, acts as slippage limit)
+             *   - `market` ("perp" | "spot"): Market type
+             *   - `type` (string, optional): Order type ("limit", "market", "stop", "take_profit")
+             *   - `triggerPrice` (number, optional): Trigger price for stop/take-profit orders
+             *   - `reduceOnly` (boolean, optional): Whether this is a reduce-only order
+             *   - `postOnly` (boolean, optional): Whether this is a post-only order
+             *
+             * **Output**: `HyperliquidPlaceOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidOrderInfo | undefined): Order information (only present on success)
+             *     - `data.orderId` (string): Order ID
+             *     - `data.symbol` (string): Trading pair symbol
+             *     - `data.side` ("buy" | "sell"): Order side
+             *     - `data.price` (number): Order price
+             *     - `data.size` (number): Order size
+             *     - `data.filled` (number): Filled amount
+             *     - `data.status` (string): Order status
+             *     - `data.market` ("perp" | "spot"): Market type
+             *     - `data.clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @param request - Order parameters
+             * @returns Promise resolving to HyperliquidPlaceOrderResponse
+             *
+             * @example
+             * ```ts
+             * // Market order
+             * const result = await agent.platforms.hyperliquid.placeOrder({
+             *   symbol: "BTC-USD",
+             *   side: "buy",
+             *   size: 0.0001,
+             *   price: 110000,
+             *   market: "perp",
+             *   type: "market",
+             * });
+             *
+             * // Limit order
+             * const result = await agent.platforms.hyperliquid.placeOrder({
+             *   symbol: "BTC-USD",
+             *   side: "buy",
+             *   size: 0.0001,
+             *   price: 100000,
+             *   market: "perp",
+             *   type: "limit",
+             * });
+             *
+             * if (result.success && result.data) {
+             *   await agent.log(`Order placed: ${result.data.orderId}`);
+             *   await agent.log(`Status: ${result.data.status}`);
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            placeOrder: (request: HyperliquidPlaceOrderRequest) => Promise<HyperliquidPlaceOrderResponse>;
+            /**
+             * Get order information by order ID
+             *
+             * Retrieve details for a specific order including status, filled amount, and price.
+             *
+             * **Input**: `orderId` (string) - Unique order identifier
+             *
+             * **Output**: `HyperliquidOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidOrderInfo | undefined): Order details (only present on success)
+             *     - `data.orderId` (string): Order ID
+             *     - `data.symbol` (string): Trading pair symbol
+             *     - `data.side` ("buy" | "sell"): Order side
+             *     - `data.price` (number): Order price
+             *     - `data.size` (number): Order size
+             *     - `data.filled` (number): Filled amount
+             *     - `data.status` (string): Order status
+             *     - `data.market` ("perp" | "spot"): Market type
+             *     - `data.clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @param orderId - Order ID to query
+             * @returns Promise resolving to HyperliquidOrderResponse
+             *
+             * @example
+             * ```ts
+             * const result = await agent.platforms.hyperliquid.order("12345");
+             * if (result.success && result.data) {
+             *   await agent.log(`Order ${result.data.orderId}: ${result.data.status}`);
+             *   await agent.log(`Filled: ${result.data.filled}/${result.data.size}`);
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            order: (orderId: string) => Promise<HyperliquidOrderResponse>;
+            /**
+             * Cancel an order
+             *
+             * Cancel an open order by order ID and symbol.
+             *
+             * **Input**:
+             *   - `orderId` (string): Order ID to cancel
+             *   - `symbol` (string): Trading symbol
+             *
+             * **Output**: `HyperliquidDeleteOrderResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * Note: This operation returns no data on success (void response).
+             *
+             * @param orderId - Order ID to cancel
+             * @param symbol - Trading symbol
+             * @returns Promise resolving to HyperliquidDeleteOrderResponse
+             *
+             * @example
+             * ```ts
+             * const result = await agent.platforms.hyperliquid.deleteOrder("12345", "BTC-USD");
+             * if (result.success) {
+             *   await agent.log("Order cancelled successfully");
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            deleteOrder: (orderId: string, symbol: string) => Promise<HyperliquidDeleteOrderResponse>;
+            /**
+             * Get account balances
+             *
+             * Retrieve perp and spot account balances.
+             *
+             * **Output**: `HyperliquidBalancesResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidBalances | undefined): Balance data (only present on success)
+             *     - `data.perp` (HyperliquidPerpBalance): Perp account balance
+             *       - `data.perp.accountValue` (string): Total account value
+             *       - `data.perp.totalMarginUsed` (string): Total margin used
+             *       - `data.perp.withdrawable` (string): Withdrawable amount
+             *     - `data.spot` (HyperliquidSpotBalance[]): Spot token balances
+             *       - `data.spot[].coin` (string): Token symbol
+             *       - `data.spot[].total` (string): Total balance
+             *       - `data.spot[].hold` (string): Amount on hold
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidBalancesResponse
+             *
+             * @example
+             * ```ts
+             * const result = await agent.platforms.hyperliquid.balances();
+             * if (result.success && result.data) {
+             *   await agent.log(`Account value: ${result.data.perp.accountValue}`);
+             *   await agent.log(`Withdrawable: ${result.data.perp.withdrawable}`);
+             *   for (const balance of result.data.spot) {
+             *     await agent.log(`${balance.coin}: ${balance.total}`);
+             *   }
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            balances: () => Promise<HyperliquidBalancesResponse>;
+            /**
+             * Get open positions
+             *
+             * Retrieve all open perpetual positions with PnL and position details.
+             *
+             * **Output**: `HyperliquidPositionsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidPosition[] | undefined): Array of open positions (only present on success)
+             *     - `data[].symbol` (string): Trading pair symbol (e.g., "BTC-USD")
+             *     - `data[].side` ("long" | "short"): Position side
+             *     - `data[].size` (string): Position size
+             *     - `data[].entryPrice` (string): Average entry price
+             *     - `data[].markPrice` (string): Current mark price
+             *     - `data[].liquidationPrice` (string | null): Liquidation price (null if no risk)
+             *     - `data[].unrealizedPnl` (string): Unrealized profit/loss
+             *     - `data[].leverage` (string): Current leverage
+             *     - `data[].marginUsed` (string): Margin allocated to position
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidPositionsResponse
+             *
+             * @example
+             * ```ts
+             * const result = await agent.platforms.hyperliquid.positions();
+             * if (result.success && result.data) {
+             *   for (const pos of result.data) {
+             *     await agent.log(`${pos.symbol}: ${pos.side} ${pos.size}`);
+             *     await agent.log(`Entry: ${pos.entryPrice}, Mark: ${pos.markPrice}`);
+             *     await agent.log(`Unrealized PnL: ${pos.unrealizedPnl}`);
+             *   }
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            positions: () => Promise<HyperliquidPositionsResponse>;
+            /**
+             * Get open orders
+             *
+             * Retrieve all currently open orders.
+             *
+             * **Output**: `HyperliquidOpenOrdersResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidOrderInfo[] | undefined): Array of open orders (only present on success)
+             *     - `data[].orderId` (string): Order ID
+             *     - `data[].symbol` (string): Trading pair symbol
+             *     - `data[].side` ("buy" | "sell"): Order side
+             *     - `data[].price` (number): Order price
+             *     - `data[].size` (number): Order size
+             *     - `data[].filled` (number): Filled amount
+             *     - `data[].status` (string): Order status
+             *     - `data[].market` ("perp" | "spot"): Market type
+             *     - `data[].clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidOpenOrdersResponse
+             *
+             * @example
+             * ```ts
+             * const result = await agent.platforms.hyperliquid.openOrders();
+             * if (result.success && result.data) {
+             *   await agent.log(`You have ${result.data.length} open orders`);
+             *   for (const order of result.data) {
+             *     await agent.log(`${order.symbol}: ${order.side} ${order.size} @ ${order.price}`);
+             *   }
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            openOrders: () => Promise<HyperliquidOpenOrdersResponse>;
+            /**
+             * Get order fill history
+             *
+             * Retrieve order fill history including partial and complete fills.
+             *
+             * **Output**: `HyperliquidOrderFillsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidFill[] | undefined): Array of order fills (only present on success)
+             *     - `data[].orderId` (string): Order ID
+             *     - `data[].symbol` (string): Trading pair symbol
+             *     - `data[].side` ("buy" | "sell"): Fill side
+             *     - `data[].price` (string): Fill price
+             *     - `data[].size` (string): Fill size
+             *     - `data[].fee` (string): Trading fee paid
+             *     - `data[].timestamp` (number): Fill timestamp in milliseconds
+             *     - `data[].isMaker` (boolean): True if maker, false if taker
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidOrderFillsResponse
+             *
+             * @example
+             * ```ts
+             * const result = await agent.platforms.hyperliquid.orderFills();
+             * if (result.success && result.data) {
+             *   await agent.log(`Total fills: ${result.data.length}`);
+             *   for (const fill of result.data) {
+             *     const fillType = fill.isMaker ? "maker" : "taker";
+             *     await agent.log(`${fill.symbol}: ${fill.size} @ ${fill.price} (${fillType}, fee: ${fill.fee})`);
+             *   }
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            orderFills: () => Promise<HyperliquidOrderFillsResponse>;
+            /**
+             * Get historical orders
+             *
+             * Retrieve order history including filled, cancelled, and expired orders.
+             *
+             * **Output**: `HyperliquidHistoricalOrdersResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidHistoricalOrder[] | undefined): Array of historical orders (only present on success)
+             *     - `data[].orderId` (string): Order ID
+             *     - `data[].symbol` (string): Trading pair symbol
+             *     - `data[].side` ("buy" | "sell"): Order side
+             *     - `data[].price` (number): Order price
+             *     - `data[].size` (number): Order size
+             *     - `data[].filled` (number): Filled amount
+             *     - `data[].status` ("open" | "filled" | "canceled" | "triggered" | "rejected" | "marginCanceled" | "liquidatedCanceled"): Order status
+             *     - `data[].market` ("perp" | "spot"): Market type
+             *     - `data[].timestamp` (number): Order creation timestamp in milliseconds
+             *     - `data[].statusTimestamp` (number): Status update timestamp in milliseconds
+             *     - `data[].orderType` ("Market" | "Limit" | "Stop Market" | "Stop Limit" | "Take Profit Market" | "Take Profit Limit"): Order type
+             *     - `data[].clientOrderId` (string | undefined): Client order ID
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @returns Promise resolving to HyperliquidHistoricalOrdersResponse
+             *
+             * @example
+             * ```ts
+             * const result = await agent.platforms.hyperliquid.orders();
+             * if (result.success && result.data) {
+             *   await agent.log(`Order history: ${result.data.length} orders`);
+             *   const filled = result.data.filter(o => o.status === "filled");
+             *   await agent.log(`Filled orders: ${filled.length}`);
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            orders: () => Promise<HyperliquidHistoricalOrdersResponse>;
+            /**
+             * Transfer between spot and perp accounts
+             *
+             * Move funds between your spot wallet and perpetuals trading account.
+             *
+             * **Input**: `HyperliquidTransferRequest`
+             *   - `amount` (number): Amount to transfer
+             *   - `toPerp` (boolean): True to transfer to perp account, False to transfer to spot
+             *
+             * **Output**: `HyperliquidTransferResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * Note: This operation returns no data on success (void response).
+             *
+             * @param request - Transfer parameters
+             * @returns Promise resolving to HyperliquidTransferResponse
+             *
+             * @example
+             * ```ts
+             * // Transfer 1000 USDC to perp account
+             * const result = await agent.platforms.hyperliquid.transfer({
+             *   amount: 1000,
+             *   toPerp: true
+             * });
+             *
+             * if (result.success) {
+             *   await agent.log("Transfer completed successfully");
+             * } else {
+             *   await agent.log(`Error: ${result.error}`, { error: true });
+             * }
+             * ```
+             */
+            transfer: (request: HyperliquidTransferRequest) => Promise<HyperliquidTransferResponse>;
+            /**
+             * Get liquidation events
+             *
+             * Retrieve liquidation events for the account, optionally filtered by start time.
+             *
+             * **Input**: `startTime` (number, optional) - Unix timestamp in milliseconds to filter liquidations from
+             *
+             * **Output**: `HyperliquidLiquidationsResponse`
+             *   - `success` (boolean): Whether the operation was successful
+             *   - `data` (HyperliquidLiquidation[] | undefined): Array of liquidation events (only present on success)
+             *     - `data[].timestamp` (number): Liquidation timestamp in milliseconds
+             *     - `data[].liquidatedPositions` (HyperliquidLiquidatedPosition[]): Liquidated positions
+             *       - `data[].liquidatedPositions[].symbol` (string): Position symbol (e.g., "BTC-USD")
+             *       - `data[].liquidatedPositions[].side` ("long" | "short"): Position side
+             *       - `data[].liquidatedPositions[].size` (string): Position size that was liquidated
+             *     - `data[].totalNotional` (string): Total notional value liquidated
+             *     - `data[].accountValue` (string): Account value at liquidation
+             *     - `data[].leverageType` ("Cross" | "Isolated"): Leverage type
+             *     - `data[].txHash` (string): Transaction hash
+             *   - `error` (string | undefined): Error message (only present on failure)
+             *
+             * @param startTime - Optional start time for filtering (Unix timestamp in milliseconds)
+             * @returns Promise resolving to HyperliquidLiquidationsResponse
+             *
+             * @example
+             * ```ts
+             * // Get all liquidations (defaults to last 30 days)
+             * const all = await agent.platforms.hyperliquid.liquidations();
+             *
+             * // Get liquidations from last 24h
+             * const yesterday = Date.now() - (24 * 60 * 60 * 1000);
+             * const recent = await agent.platforms.hyperliquid.liquidations(yesterday);
+             *
+             * if (recent.success && recent.data) {
+             *   await agent.log(`Liquidations in last 24h: ${recent.data.length}`);
+             *   for (const liq of recent.data) {
+             *     await agent.log(`Liquidated ${liq.liquidatedPositions.length} positions`);
+             *   }
+             * } else {
+             *   await agent.log(`Error: ${recent.error}`, { error: true });
+             * }
+             * ```
+             */
+            liquidations: (startTime?: number) => Promise<HyperliquidLiquidationsResponse>;
+        };
     };
     /**
      * Access cross-chain swap and bridge operations.
@@ -2560,4 +3632,4 @@ declare function isSolanaNetwork(network: Network): network is "solana";
  */
 declare function getChainIdFromNetwork(network: `ethereum:${number}`): number;
 
-export { APIClient, Agent, AgentContext, AgentSdk, type AssetChange, type CurrentPosition, type CurrentPositionsData, type CurrentPositionsResponse, type EnrichedPosition, type LogResponse, type MemoryDeleteResponse, type MemoryGetResponse, type MemoryListResponse, type MemorySetResponse, type Network, type PolymarketMarketOrderRequest, type PolymarketMarketOrderResponse, type PolymarketRedeemPositionsRequest, type PolymarketRedeemPositionsResponse, QUOTE_RESULT, type SDKConfig, type SignAndSendRequest, type SignAndSendResponse, type SignMessageRequest, type SignMessageResponse, type StopFunctionContract, type SwidgeExecuteResponse, type SwidgeQuoteRequest, type SwidgeQuoteResponse, type SwidgeQuoteResult, type TransactionsResponse, getChainIdFromNetwork, isEthereumNetwork, isSolanaNetwork, type runFunctionContract };
+export { APIClient, Agent, AgentContext, AgentSdk, type AssetChange, type CurrentPosition, type CurrentPositionsData, type CurrentPositionsResponse, type EnrichedPosition, type HyperliquidBalancesResponse, type HyperliquidDeleteOrderResponse, type HyperliquidHistoricalOrdersResponse, type HyperliquidLiquidationsResponse, type HyperliquidOpenOrdersResponse, type HyperliquidOrderFillsResponse, type HyperliquidOrderResponse, type HyperliquidPlaceOrderRequest, type HyperliquidPlaceOrderResponse, type HyperliquidPositionsResponse, type HyperliquidTransferRequest, type HyperliquidTransferResponse, type LogResponse, type MemoryDeleteResponse, type MemoryGetResponse, type MemoryListResponse, type MemorySetResponse, type Network, type PolymarketMarketOrderRequest, type PolymarketMarketOrderResponse, type PolymarketRedeemPositionsRequest, type PolymarketRedeemPositionsResponse, QUOTE_RESULT, type SDKConfig, type SignAndSendRequest, type SignAndSendResponse, type SignMessageRequest, type SignMessageResponse, type StopFunctionContract, type SwidgeExecuteResponse, type SwidgeQuoteRequest, type SwidgeQuoteResponse, type SwidgeQuoteResult, type TransactionsResponse, getChainIdFromNetwork, isEthereumNetwork, isSolanaNetwork, type runFunctionContract };