feat: perp long and short

Author: spacesailor24

packages/apps/ability-hyperliquid/src/generated/lit-action.js

@@ -1,3 +1,3 @@
 {
-  "ipfsCid": "QmTEJvuurEEB3zKxVHU8zMFWEfV2CgoNZiUTxxPK4FkZ13"
+  "ipfsCid": "QmUpGqvnfLEthsyK9MYM59794SEKerPhe7Jv1fDLLggZTz"
 }

packages/apps/ability-hyperliquid/src/generated/vincent-ability-metadata.json

@@ -1,2 +1,3 @@
 export { depositPrechecks } from './deposit';
 export { spotTradePrechecks } from './spot';
+export { perpTradePrechecks } from './perp';

packages/apps/ability-hyperliquid/src/lib/ability-checks/index.ts

@@ -0,0 +1,80 @@
+import * as hyperliquid from '@nktkas/hyperliquid';
+import { SymbolConverter } from '@nktkas/hyperliquid/utils';
+
+export interface PerpTradeParams {
+  symbol: string;
+  price: string;
+  size: string;
+}
+
+/**
+ * Check if perpetual trade can be executed
+ */
+export async function perpTradePrechecks(
+  transport: hyperliquid.HttpTransport,
+  userAddress: string,
+  params: PerpTradeParams,
+): Promise<{ success: boolean; reason?: string; assetId?: number }> {
+  try {
+    const converter = await SymbolConverter.create({ transport });
+    const assetId = converter.getAssetId(params.symbol);
+
+    if (assetId === undefined) {
+      return {
+        success: false,
+        reason: `Perpetual contract ${params.symbol} does not exist`,
+      };
+    }
+
+    // Check if account exists
+    const infoClient = new hyperliquid.InfoClient({ transport });
+    try {
+      await infoClient.clearinghouseState({ user: userAddress as `0x${string}` });
+      // If this succeeds, account exists
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes('does not exist')) {
+        return {
+          success: false,
+          reason: 'Hyperliquid account does not exist. Please deposit first.',
+          assetId,
+        };
+      }
+      throw error;
+    }
+
+    // Check perp balance to ensure user has funds
+    const perpState = await infoClient.clearinghouseState({
+      user: userAddress as `0x${string}`,
+    });
+
+    // Check if user has any cross margin value or margin summary
+    const crossMarginSummary = perpState.crossMarginSummary;
+    if (!crossMarginSummary) {
+      return {
+        success: false,
+        reason: 'No perp account found. Please transfer funds to perp account first.',
+        assetId,
+      };
+    }
+
+    const accountValue = parseFloat(crossMarginSummary.accountValue);
+    if (accountValue <= 0) {
+      return {
+        success: false,
+        reason: 'Insufficient perp account balance. Please transfer funds to perp account first.',
+        assetId,
+      };
+    }
+
+    return {
+      success: true,
+      assetId,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

packages/apps/ability-hyperliquid/src/lib/ability-checks/perp.ts

@@ -9,7 +9,7 @@ import { LitActionPkpEthersWallet } from '../lit-action-pkp-ethers-wallet';
 /**
  * Cancel all open spot orders for a specific symbol
  */
-export async function cancelAllSpotOrders({
+export async function cancelAllOrdersForSymbol({
   transport,
   pkpPublicKey,
   symbol,

packages/apps/ability-hyperliquid/src/lib/ability-helpers/spot/cancel-all-orders.ts renamed to packages/apps/ability-hyperliquid/src/lib/ability-helpers/cancel-order/cancel-all-orders.ts

@@ -14,7 +14,7 @@ export interface CancelSpotOrderParams {
 /**
  * Cancel a specific spot order on Hyperliquid
  */
-export async function cancelSpotOrder({
+export async function cancelOrder({
   transport,
   pkpPublicKey,
   params,

packages/apps/ability-hyperliquid/src/lib/ability-helpers/spot/cancel-order.ts renamed to packages/apps/ability-hyperliquid/src/lib/ability-helpers/cancel-order/cancel-order.ts

@@ -0,0 +1,178 @@
+import * as hyperliquid from '@nktkas/hyperliquid';
+import { SymbolConverter } from '@nktkas/hyperliquid/utils';
+import { OrderRequest, UpdateLeverageRequest, parser } from '@nktkas/hyperliquid/api/exchange';
+import { signL1Action } from '@nktkas/hyperliquid/signing';
+import { bigIntReplacer } from '@lit-protocol/vincent-ability-sdk';
+
+import { LitActionPkpEthersWallet } from './lit-action-pkp-ethers-wallet';
+
+export type TimeInForce = 'Gtc' | 'Ioc' | 'Alo';
+
+export interface PerpTradeParams {
+  symbol: string;
+  price: string;
+  size: string;
+  isLong: boolean; // true for long, false for short
+  /**
+   * Order type configuration.
+   * - For limit orders: specify { type: 'limit', tif: 'Gtc' | 'Ioc' | 'Alo' }
+   * - For market orders: specify { type: 'market' }
+   * @default { type: 'limit', tif: 'Gtc' }
+   */
+  orderType?: { type: 'limit'; tif: TimeInForce } | { type: 'market' };
+  /**
+   * Leverage configuration.
+   * @default { leverage: 2, isCross: true }
+   */
+  leverage?: {
+    leverage: number; // 1-50x
+    isCross: boolean; // true for cross margin, false for isolated
+  };
+}
+
+/**
+ * Execute a perpetual trade on Hyperliquid
+ */
+export async function executePerpOrder({
+  transport,
+  pkpPublicKey,
+  params,
+  useTestnet = false,
+}: {
+  transport: hyperliquid.HttpTransport;
+  pkpPublicKey: string;
+  params: PerpTradeParams;
+  useTestnet?: boolean;
+}) {
+  // Get converter for symbol to asset ID
+  const converter = await SymbolConverter.create({ transport });
+  const assetId = converter.getAssetId(params.symbol);
+
+  if (assetId === undefined) {
+    throw new Error(
+      `Failed to get asset ID for ${params.symbol}. The perpetual contract may not exist.`,
+    );
+  }
+
+  // Create PKP wallet
+  const pkpWallet = new LitActionPkpEthersWallet(pkpPublicKey);
+  const pkpAddress = await pkpWallet.getAddress();
+
+  // Set leverage if specified
+  if (params.leverage) {
+    const leverageNonceResponse = await Lit.Actions.runOnce(
+      { waitForResponse: true, name: 'HyperLiquidPerpLeverageNonce' },
+      async () => {
+        return Date.now().toString();
+      },
+    );
+    const leverageNonce = parseInt(leverageNonceResponse);
+
+    const updateLeverageAction = parser(UpdateLeverageRequest.entries.action)({
+      type: 'updateLeverage',
+      asset: assetId,
+      isCross: params.leverage.isCross,
+      leverage: params.leverage.leverage,
+    });
+
+    const leverageSignature = await signL1Action({
+      wallet: pkpWallet,
+      action: updateLeverageAction,
+      nonce: leverageNonce,
+      isTestnet: useTestnet,
+    });
+
+    await Lit.Actions.runOnce(
+      { waitForResponse: true, name: 'HyperLiquidPerpLeverageRequest' },
+      async () => {
+        return JSON.stringify(
+          await transport.request('exchange', {
+            action: updateLeverageAction,
+            signature: leverageSignature,
+            nonce: leverageNonce,
+          }),
+        );
+      },
+    );
+
+    console.log(
+      `[executePerpOrder] Set leverage to ${params.leverage.leverage}x (${params.leverage.isCross ? 'cross' : 'isolated'})`,
+    );
+  }
+
+  // Generate deterministic nonce for order in runOnce
+  const nonceResponse = await Lit.Actions.runOnce(
+    { waitForResponse: true, name: 'HyperLiquidPerpOrderNonce' },
+    async () => {
+      return Date.now().toString();
+    },
+  );
+  const nonce = parseInt(nonceResponse);
+
+  // Determine order type configuration
+  const orderType = params.orderType || { type: 'limit', tif: 'Gtc' };
+
+  // Construct order type field based on orderType
+  const orderTypeField =
+    orderType.type === 'market'
+      ? { limit: { tif: 'FrontendMarket' } }
+      : { limit: { tif: orderType.tif } };
+
+  // Construct order action
+  const orderAction = parser(OrderRequest.entries.action)({
+    type: 'order',
+    orders: [
+      {
+        a: assetId,
+        b: params.isLong, // true for long (buy), false for short (sell)
+        p: params.price,
+        s: params.size,
+        r: false, // reduce only (false for opening positions)
+        t: orderTypeField,
+      },
+    ],
+    grouping: 'na',
+  });
+
+  // Sign and send
+  const signature = await signL1Action({
+    wallet: pkpWallet,
+    action: orderAction,
+    nonce,
+    isTestnet: useTestnet,
+  });
+
+  const orderResult = await Lit.Actions.runOnce(
+    { waitForResponse: true, name: 'HyperLiquidPerpOrderRequest' },
+    async () => {
+      return JSON.stringify(
+        {
+          result: await transport.request('exchange', {
+            action: orderAction,
+            signature,
+            nonce,
+          }),
+        },
+        bigIntReplacer,
+        2,
+      );
+    },
+  );
+
+  const parsedOrderResult = JSON.parse(orderResult);
+  console.log('[executePerpOrder] Order result', parsedOrderResult);
+
+  const perpOrderStatus = parsedOrderResult.result.response.data.statuses[0];
+
+  if (perpOrderStatus.error !== undefined) {
+    return {
+      status: 'error',
+      error: perpOrderStatus.error,
+    };
+  }
+
+  return {
+    status: 'success',
+    orderResult: parsedOrderResult.result as Record<string, unknown>,
+  };
+}

packages/apps/ability-hyperliquid/src/lib/ability-helpers/execute-perp-order.ts

@@ -4,7 +4,7 @@ import { OrderRequest, parser } from '@nktkas/hyperliquid/api/exchange';
 import { signL1Action } from '@nktkas/hyperliquid/signing';
 import { bigIntReplacer } from '@lit-protocol/vincent-ability-sdk';
 
-import { LitActionPkpEthersWallet } from '../lit-action-pkp-ethers-wallet';
+import { LitActionPkpEthersWallet } from './lit-action-pkp-ethers-wallet';
 
 export type TimeInForce = 'Gtc' | 'Ioc' | 'Alo';
 

packages/apps/ability-hyperliquid/src/lib/ability-helpers/spot/execute-order.ts renamed to packages/apps/ability-hyperliquid/src/lib/ability-helpers/execute-spot-order.ts

@@ -1,5 +1,7 @@
-export * from './perp-trade';
-export * from './spot';
 export { LitActionPkpEthersWallet } from './lit-action-pkp-ethers-wallet';
+export { cancelOrder } from './cancel-order/cancel-order';
+export { cancelAllOrdersForSymbol } from './cancel-order/cancel-all-orders';
 export { sendDepositTx } from './send-deposit-tx';
 export { transferUsdcTo } from './transfer-usdc-to';
+export { executeSpotOrder } from './execute-spot-order';
+export { executePerpOrder } from './execute-perp-order';