@lifi/perps-sdk 0.1.1-alpha.9 → 1.0.0

package/src/services/getDexes.ts

@@ -1,34 +0,0 @@
-import type { DexesResponse } from '@lifi/perps-types'
-import type {
-  PerpsSDKClient,
-  SDKRequestOptions,
-} from '../client/createPerpsClient.js'
-import { request } from '../utils/request.js'
-
-/**
- * Get all available DEXes.
- *
- * @param client - The SDK client instance
- * @param options - Request options (e.g., AbortSignal)
- * @returns List of supported DEXes with their authorization requirements
- * @throws {HTTPError} On API error responses
- * @throws {PerpsError} On network or parsing errors
- *
- * @example
- * ```ts
- * const client = createPerpsClient({ integrator: 'my-app' })
- * const { dexes } = await getDexes(client)
- * console.log(dexes) // [{ key: 'hyperliquid', name: 'Hyperliquid', ... }]
- * ```
- */
-export async function getDexes(
-  client: PerpsSDKClient,
-  options?: SDKRequestOptions
-): Promise<DexesResponse> {
-  return request<DexesResponse>(
-    client.config,
-    `${client.config.apiUrl}/dexes`,
-    {},
-    options
-  )
-}

package/src/services/getHistory.ts

@@ -1,62 +0,0 @@
-import type { Address, HistoryResponse } from '@lifi/perps-types'
-import type {
-  PerpsSDKClient,
-  SDKRequestOptions,
-} from '../client/createPerpsClient.js'
-import { buildUrl, request } from '../utils/request.js'
-
-export interface GetHistoryParams {
-  /** DEX to get history from (e.g., 'hyperliquid') */
-  dex: string
-  /** Wallet address */
-  address: Address
-  /** Maximum number of items to return */
-  limit?: number
-  /** Cursor for pagination */
-  cursor?: string
-}
-
-/**
- * Get order history for an account.
- *
- * @param client - The SDK client instance
- * @param params - Request parameters
- * @param options - Request options (e.g., AbortSignal)
- * @returns Order history with pagination
- * @throws {HTTPError} On API error responses
- * @throws {PerpsError} On network or parsing errors
- *
- * @example
- * ```ts
- * const client = createPerpsClient({ integrator: 'my-app' })
- * const { items, pagination } = await getHistory(client, {
- *   dex: 'hyperliquid',
- *   address: '0x1234...',
- *   limit: 50
- * })
- *
- * console.log(items) // [{ id: '123', symbol: 'BTC', status: 'FILLED', ... }]
- *
- * // Fetch next page
- * if (pagination.hasMore) {
- *   const nextPage = await getHistory(client, {
- *     dex: 'hyperliquid',
- *     address: '0x1234...',
- *     cursor: pagination.cursor
- *   })
- * }
- * ```
- */
-export async function getHistory(
-  client: PerpsSDKClient,
-  params: GetHistoryParams,
-  options?: SDKRequestOptions
-): Promise<HistoryResponse> {
-  const url = buildUrl(`${client.config.apiUrl}/history`, {
-    dex: params.dex,
-    address: params.address,
-    limit: params.limit,
-    cursor: params.cursor,
-  })
-  return request<HistoryResponse>(client.config, url, {}, options)
-}

package/src/services/submitAuthorization.ts

@@ -1,70 +0,0 @@
-import type {
-  Address,
-  AuthorizationsResponse,
-  SignedAuthorization,
-} from '@lifi/perps-types'
-import type {
-  PerpsSDKClient,
-  SDKRequestOptions,
-} from '../client/createPerpsClient.js'
-import { request } from '../utils/request.js'
-
-export interface SubmitAuthorizationParams {
-  /** DEX to authorize (e.g., 'hyperliquid') */
-  dex: string
-  /** Wallet address */
-  address: Address
-  /** Address of the signer (for agent mode, this is the agent address) */
-  signerAddress?: Address
-  /** Signed authorization actions */
-  actions: SignedAuthorization[]
-}
-
-/**
- * Submit signed authorizations to the DEX.
- *
- * @param client - The SDK client instance
- * @param params - Request parameters
- * @param options - Request options (e.g., AbortSignal)
- * @returns Results for each authorization action
- * @throws {HTTPError} On API error responses
- * @throws {PerpsError} On network or parsing errors
- *
- * @example
- * ```ts
- * const client = createPerpsClient({ integrator: 'my-app' })
- * const { results } = await submitAuthorization(client, {
- *   dex: 'hyperliquid',
- *   address: '0x1234...',
- *   actions: signedActions
- * })
- *
- * for (const result of results) {
- *   if (result.success) {
- *     console.log(`${result.action} authorized`)
- *   } else {
- *     console.error(`${result.action} failed: ${result.error}`)
- *   }
- * }
- * ```
- */
-export async function submitAuthorization(
-  client: PerpsSDKClient,
-  params: SubmitAuthorizationParams,
-  options?: SDKRequestOptions
-): Promise<AuthorizationsResponse> {
-  return request<AuthorizationsResponse>(
-    client.config,
-    `${client.config.apiUrl}/authorization`,
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        dex: params.dex,
-        address: params.address,
-        signerAddress: params.signerAddress,
-        actions: params.actions,
-      }),
-    },
-    options
-  )
-}

package/src/services/submitOrder.ts

@@ -1,72 +0,0 @@
-import type {
-  Address,
-  SignedOrderAction,
-  SubmitOrderResponse,
-} from '@lifi/perps-types'
-import type {
-  PerpsSDKClient,
-  SDKRequestOptions,
-} from '../client/createPerpsClient.js'
-import { request } from '../utils/request.js'
-
-export interface SubmitOrderParams {
-  /** DEX to submit order to (e.g., 'hyperliquid') */
-  dex: string
-  /** Wallet address */
-  address: Address
-  /** Address of the signer (for agent mode, this is the agent address) */
-  signerAddress?: Address
-  /** Signed order actions */
-  actions: SignedOrderAction[]
-}
-
-/**
- * Submit signed order actions to the DEX.
- *
- * @param client - The SDK client instance
- * @param params - Request parameters
- * @param options - Request options (e.g., AbortSignal)
- * @returns Results for each order action
- * @throws {HTTPError} On API error responses
- * @throws {PerpsError} On network or parsing errors
- *
- * @example
- * ```ts
- * const client = createPerpsClient({ integrator: 'my-app' })
- *
- * // After creating and signing order actions
- * const { results } = await submitOrder(client, {
- *   dex: 'hyperliquid',
- *   address: '0x1234...',
- *   actions: signedActions
- * })
- *
- * for (const result of results) {
- *   if (result.success) {
- *     console.log(`Order placed: ${result.orderId}`)
- *   } else {
- *     console.error(`Order failed: ${result.error}`)
- *   }
- * }
- * ```
- */
-export async function submitOrder(
-  client: PerpsSDKClient,
-  params: SubmitOrderParams,
-  options?: SDKRequestOptions
-): Promise<SubmitOrderResponse> {
-  return request<SubmitOrderResponse>(
-    client.config,
-    `${client.config.apiUrl}/order`,
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        dex: params.dex,
-        address: params.address,
-        signerAddress: params.signerAddress,
-        actions: params.actions,
-      }),
-    },
-    options
-  )
-}

package/src/services/submitWithdrawal.ts

@@ -1,67 +0,0 @@
-import type {
-  Address,
-  SignedWithdrawal,
-  SubmitWithdrawalResponse,
-} from '@lifi/perps-types'
-import type {
-  PerpsSDKClient,
-  SDKRequestOptions,
-} from '../client/createPerpsClient.js'
-import { request } from '../utils/request.js'
-
-export interface SubmitWithdrawalParams {
-  /** DEX to withdraw from (e.g., 'hyperliquid') */
-  dex: string
-  /** Wallet address (account owner) */
-  address: Address
-  /** Signed withdrawal action */
-  action: SignedWithdrawal
-}
-
-/**
- * Submit a signed withdrawal to the DEX.
- *
- * Withdrawals are user-signed only — agents cannot initiate withdrawals.
- *
- * @param client - The SDK client instance
- * @param params - Request parameters
- * @param options - Request options (e.g., AbortSignal)
- * @returns Withdrawal result
- * @throws {HTTPError} On API error responses
- * @throws {PerpsError} On network or parsing errors
- *
- * @example
- * ```ts
- * const client = createPerpsClient({ integrator: 'my-app' })
- * const { result } = await submitWithdrawal(client, {
- *   dex: 'hyperliquid',
- *   address: '0x1234...',
- *   action: signedAction,
- * })
- *
- * if (result.success) {
- *   console.log('Withdrawal submitted')
- * } else {
- *   console.error(`Withdrawal failed: ${result.error}`)
- * }
- * ```
- */
-export async function submitWithdrawal(
-  client: PerpsSDKClient,
-  params: SubmitWithdrawalParams,
-  options?: SDKRequestOptions
-): Promise<SubmitWithdrawalResponse> {
-  return request<SubmitWithdrawalResponse>(
-    client.config,
-    `${client.config.apiUrl}/withdrawal`,
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        dex: params.dex,
-        address: params.address,
-        action: params.action,
-      }),
-    },
-    options
-  )
-}

package/src/utils/request.ts

@@ -1,116 +0,0 @@
-import { PerpsErrorCode } from '@lifi/perps-types'
-import type {
-  PerpsBaseConfig,
-  SDKRequestOptions,
-} from '../client/createPerpsClient.js'
-import { HTTPError } from '../errors/HTTPError.js'
-import { PerpsError } from '../errors/PerpsError.js'
-import { version } from '../version.js'
-import { sleep } from './sleep.js'
-
-export interface RequestOptions extends RequestInit {
-  /** Number of retries on 5xx errors. Default: 1 */
-  retries?: number
-}
-
-const DEFAULT_RETRIES = 1
-
-/**
- * Make an HTTP request to the Perps API.
- *
- * @param config - SDK configuration
- * @param url - The full URL to request
- * @param options - Fetch options plus retries
- * @param sdkOptions - SDK-specific options (signal, etc.)
- * @returns Parsed JSON response
- * @throws {HTTPError} On non-2xx responses
- * @throws {PerpsError} On network or parsing errors
- */
-export async function request<T>(
-  config: PerpsBaseConfig,
-  url: string,
-  options: RequestOptions = {},
-  sdkOptions?: SDKRequestOptions
-): Promise<T> {
-  const retries = options.retries ?? DEFAULT_RETRIES
-
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-    'x-lifi-integrator': config.integrator,
-    'x-lifi-perps-sdk': version,
-    ...(options.headers as Record<string, string>),
-  }
-
-  if (config.apiKey) {
-    headers['x-lifi-api-key'] = config.apiKey
-  }
-
-  // Merge signal from sdkOptions into options
-  let finalOptions: RequestInit = {
-    ...options,
-    headers,
-    signal: sdkOptions?.signal ?? options.signal,
-  }
-
-  // Apply request interceptor if configured
-  if (config.requestInterceptor) {
-    finalOptions = await config.requestInterceptor(url, finalOptions)
-  }
-
-  try {
-    const response = await fetch(url, finalOptions)
-
-    if (!response.ok) {
-      const error = new HTTPError(response, url)
-      await error.buildAdditionalDetails()
-
-      // Retry on 5xx errors
-      if (retries > 0 && response.status >= 500) {
-        await sleep(500)
-        return request<T>(
-          config,
-          url,
-          { ...options, retries: retries - 1 },
-          sdkOptions
-        )
-      }
-
-      throw error
-    }
-
-    return (await response.json()) as T
-  } catch (error) {
-    if (error instanceof HTTPError || error instanceof PerpsError) {
-      throw error
-    }
-
-    // Network error or other fetch failure
-    throw new PerpsError(
-      PerpsErrorCode.ServerError,
-      error instanceof Error ? error.message : 'Request failed'
-    )
-  }
-}
-
-/**
- * Build a URL with query parameters.
- *
- * @param baseUrl - The base URL
- * @param params - Query parameters (undefined values are filtered out)
- * @returns Full URL with query string
- */
-export function buildUrl(
-  baseUrl: string,
-  params: Record<string, string | number | boolean | undefined>
-): string {
-  const searchParams = new URLSearchParams()
-
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== undefined) {
-      searchParams.set(key, String(value))
-    }
-  }
-
-  const queryString = searchParams.toString()
-  return queryString ? `${baseUrl}?${queryString}` : baseUrl
-}