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

package/dist/types/services/submitOrder.d.ts

@@ -1,44 +0,0 @@
-import type { Address, SignedOrderAction, SubmitOrderResponse } from '@lifi/perps-types';
-import type { PerpsSDKClient, SDKRequestOptions } from '../client/createPerpsClient.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 declare function submitOrder(client: PerpsSDKClient, params: SubmitOrderParams, options?: SDKRequestOptions): Promise<SubmitOrderResponse>;
-//# sourceMappingURL=submitOrder.d.ts.map

package/dist/types/services/submitOrder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"submitOrder.d.ts","sourceRoot":"","sources":["../../../src/services/submitOrder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EAClB,MAAM,gCAAgC,CAAA;AAGvC,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAA;IACX,qBAAqB;IACrB,OAAO,EAAE,OAAO,CAAA;IAChB,wEAAwE;IACxE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,2BAA2B;IAC3B,OAAO,EAAE,iBAAiB,EAAE,CAAA;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CAe9B"}

package/dist/types/services/submitWithdrawal.d.ts

@@ -1,40 +0,0 @@
-import type { Address, SignedWithdrawal, SubmitWithdrawalResponse } from '@lifi/perps-types';
-import type { PerpsSDKClient, SDKRequestOptions } from '../client/createPerpsClient.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 declare function submitWithdrawal(client: PerpsSDKClient, params: SubmitWithdrawalParams, options?: SDKRequestOptions): Promise<SubmitWithdrawalResponse>;
-//# sourceMappingURL=submitWithdrawal.d.ts.map

package/dist/types/services/submitWithdrawal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"submitWithdrawal.d.ts","sourceRoot":"","sources":["../../../src/services/submitWithdrawal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EAClB,MAAM,gCAAgC,CAAA;AAGvC,MAAM,WAAW,sBAAsB;IACrC,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAA;IACX,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAA;IAChB,+BAA+B;IAC/B,MAAM,EAAE,gBAAgB,CAAA;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,sBAAsB,EAC9B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,wBAAwB,CAAC,CAcnC"}

package/dist/types/utils/request.d.ts

@@ -1,26 +0,0 @@
-import type { PerpsBaseConfig, SDKRequestOptions } from '../client/createPerpsClient.js';
-export interface RequestOptions extends RequestInit {
-    /** Number of retries on 5xx errors. Default: 1 */
-    retries?: number;
-}
-/**
- * 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 declare function request<T>(config: PerpsBaseConfig, url: string, options?: RequestOptions, sdkOptions?: SDKRequestOptions): Promise<T>;
-/**
- * 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 declare function buildUrl(baseUrl: string, params: Record<string, string | number | boolean | undefined>): string;
-//# sourceMappingURL=request.d.ts.map

package/dist/types/utils/request.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/utils/request.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAClB,MAAM,gCAAgC,CAAA;AAMvC,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAC7B,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,EAC5B,UAAU,CAAC,EAAE,iBAAiB,GAC7B,OAAO,CAAC,CAAC,CAAC,CA2DZ;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,GAC5D,MAAM,CAWR"}

package/src/agent/AgentManager.ts

@@ -1,135 +0,0 @@
-import type { Address, Hex } from '@lifi/perps-types'
-import { PerpsErrorCode } from '@lifi/perps-types'
-import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
-import { PerpsErrorMessage } from '../errors/constants.js'
-import { PerpsError } from '../errors/PerpsError.js'
-import { localStorageAdapter } from './storage.js'
-import type { Agent, StorageAdapter } from './types.js'
-
-const STORAGE_PREFIX = 'lifi-perps-agent'
-
-/**
- * Manages agent keypairs for USER_AGENT signing mode.
- * Agent keys are stored per user address + DEX combination.
- */
-export class AgentManager {
-  private storage: StorageAdapter
-  private cache: Map<string, Agent> = new Map()
-
-  constructor(storage?: StorageAdapter) {
-    this.storage = storage ?? localStorageAdapter
-  }
-
-  /**
-   * Get the storage key for an agent.
-   */
-  private storageKey(address: Address, dex: string): string {
-    return `${STORAGE_PREFIX}:${address.toLowerCase()}:${dex.toLowerCase()}`
-  }
-
-  /**
-   * Get an existing agent for a user + DEX pair.
-   *
-   * @throws {PerpsError} If agent not found
-   */
-  async getAgent(address: Address, dex: string): Promise<Agent> {
-    const key = this.storageKey(address, dex)
-
-    // Check cache first
-    const cached = this.cache.get(key)
-    if (cached) {
-      return cached
-    }
-
-    // Check storage
-    const stored = await this.storage.get(key)
-    if (stored) {
-      const agent = JSON.parse(stored) as Agent
-      this.cache.set(key, agent)
-      return agent
-    }
-
-    throw new PerpsError(
-      PerpsErrorCode.AgentUnauthorized,
-      PerpsErrorMessage.AgentNotFound
-    )
-  }
-
-  /**
-   * Get an existing agent or create a new one.
-   */
-  async getOrCreateAgent(address: Address, dex: string): Promise<Agent> {
-    try {
-      return await this.getAgent(address, dex)
-    } catch {
-      // Generate new agent
-      const privateKey = generatePrivateKey()
-      const account = privateKeyToAccount(privateKey)
-
-      const agent: Agent = {
-        address: account.address,
-        privateKey,
-      }
-
-      // Store
-      const key = this.storageKey(address, dex)
-      await this.storage.set(key, JSON.stringify(agent))
-      this.cache.set(key, agent)
-
-      return agent
-    }
-  }
-
-  /**
-   * Check if an agent exists for a user + DEX pair.
-   */
-  async hasAgent(address: Address, dex: string): Promise<boolean> {
-    try {
-      await this.getAgent(address, dex)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Remove an agent for a user + DEX pair.
-   * Call this when the user revokes agent authorization.
-   */
-  async removeAgent(address: Address, dex: string): Promise<void> {
-    const key = this.storageKey(address, dex)
-    this.cache.delete(key)
-    await this.storage.remove(key)
-  }
-
-  /**
-   * Import an existing agent keypair.
-   * Useful for restoring from backup or using a specific key.
-   */
-  async importAgent(
-    address: Address,
-    dex: string,
-    privateKey: Hex
-  ): Promise<Agent> {
-    const account = privateKeyToAccount(privateKey)
-
-    const agent: Agent = {
-      address: account.address,
-      privateKey,
-    }
-
-    const key = this.storageKey(address, dex)
-    await this.storage.set(key, JSON.stringify(agent))
-    this.cache.set(key, agent)
-
-    return agent
-  }
-
-  /**
-   * Clear all cached agents.
-   * Does not remove from storage.
-   */
-  clearCache(): void {
-    this.cache.clear()
-  }
-}

package/src/agent/types.ts

@@ -1,24 +0,0 @@
-import type { Address, Hex } from '@lifi/perps-types'
-
-/**
- * Agent keypair for signing trading actions.
- */
-export interface Agent {
-  /** Agent wallet address */
-  address: Address
-  /** Agent private key */
-  privateKey: Hex
-}
-
-/**
- * Storage adapter interface for persisting agent keys.
- * Implement this interface to use custom storage (e.g., encrypted storage, database).
- */
-export interface StorageAdapter {
-  /** Get a value by key */
-  get(key: string): Promise<string | null>
-  /** Set a value by key */
-  set(key: string, value: string): Promise<void>
-  /** Remove a value by key */
-  remove(key: string): Promise<void>
-}

package/src/client/types.ts

@@ -1,162 +0,0 @@
-import type {
-  Address,
-  AuthorizationAction,
-  AuthorizationInput,
-  AuthorizationsResponse,
-  OrderSide,
-  OrderType,
-  SignedAuthorization,
-  TimeInForce,
-  TriggerOrderInput,
-  WithdrawalInput,
-} from '@lifi/perps-types'
-import type { StorageAdapter } from '../agent/types.js'
-
-// Re-export the SDK client types from createPerpsClient
-export type {
-  PerpsBaseConfig,
-  PerpsConfig,
-  PerpsSDKClient,
-  RequestInterceptor,
-  SDKRequestOptions,
-} from './createPerpsClient.js'
-
-/**
- * Signing mode determines who signs trading actions.
- *
- * - `USER`: User wallet signs each action (requires wallet popup per action)
- * - `USER_AGENT`: SDK-generated agent signs actions (no popups after initial setup)
- */
-export type SigningMode = 'USER' | 'USER_AGENT'
-
-/**
- * Options for PerpsClient constructor.
- */
-export interface PerpsClientOptions {
-  /** Integrator identifier (required) */
-  integrator: string
-  /** Optional API key for authenticated requests */
-  apiKey?: string
-  /** Base API URL. Defaults to DEFAULT_API_URL */
-  apiUrl?: string
-  /** Custom storage adapter for agent keys. Defaults to localStorage. */
-  storage?: StorageAdapter
-}
-
-/**
- * Parameters for building authorization payloads.
- */
-export interface BuildAuthorizationParams {
-  /** DEX to authorize */
-  dex: string
-  /** User wallet address */
-  address: Address
-  /** Address of the signer (auto-set in USER_AGENT mode) */
-  signerAddress?: Address
-  /** Authorizations to create */
-  authorizations: AuthorizationInput[]
-}
-
-/**
- * Parameters for placing an order.
- */
-export interface PlaceOrderParams {
-  /** DEX to place order on */
-  dex: string
-  /** User wallet address */
-  address: Address
-  /** Client-provided order ID */
-  clientOrderId?: string
-  /** Market symbol */
-  symbol: string
-  /** Order side */
-  side: OrderSide
-  /** Order type */
-  type: OrderType
-  /** Order size */
-  size: string
-  /** Order price */
-  price: string
-  /** Leverage */
-  leverage?: number
-  /** Reduce only flag */
-  reduceOnly?: boolean
-  /** Time in force */
-  timeInForce?: TimeInForce
-  /** Expiration time */
-  expiresAt?: string
-  /** Take profit trigger */
-  takeProfit?: TriggerOrderInput
-  /** Stop loss trigger */
-  stopLoss?: TriggerOrderInput
-}
-
-/**
- * Parameters for building a withdrawal payload.
- */
-export interface BuildWithdrawalParams {
-  /** DEX to withdraw from */
-  dex: string
-  /** User wallet address (account owner) */
-  address: Address
-  /** Withdrawal details */
-  withdrawal: WithdrawalInput
-}
-
-/**
- * Parameters for canceling orders.
- */
-export interface CancelOrdersParams {
-  /** DEX to cancel orders on */
-  dex: string
-  /** User wallet address */
-  address: Address
-  /** Order IDs to cancel */
-  ids: string[]
-}
-
-/**
- * Parameters for getRequiredAuthorizations().
- */
-export interface GetRequiredAuthorizationsParams {
-  /** DEX to check authorizations for */
-  dex: string
-  /** User wallet address */
-  address: Address
-}
-
-/**
- * Result from getRequiredAuthorizations().
- */
-export interface RequiredAuthorizationsResult {
-  /** Authorization actions requiring user wallet signature (with typed data for signing) */
-  userAuthorizations: AuthorizationAction[]
-  /** Authorization actions the SDK auto-signs with the agent (with typed data) */
-  agentAuthorizations: AuthorizationAction[]
-  /** Whether all authorizations are already satisfied (ready to trade) */
-  isReady: boolean
-}
-
-/**
- * Parameters for executeAuthorizations().
- */
-export interface ExecuteAuthorizationsParams {
-  /** DEX to authorize */
-  dex: string
-  /** User wallet address */
-  address: Address
-  /** The result from getRequiredAuthorizations() */
-  required: RequiredAuthorizationsResult
-  /** User-signed actions corresponding to required.userAuthorizations */
-  userSignedActions: SignedAuthorization[]
-}
-
-/**
- * Result from executeAuthorizations().
- */
-export interface ExecuteAuthorizationsResult {
-  /** Results from user-signed authorization submission */
-  userResults: AuthorizationsResponse
-  /** Results from agent-signed authorization submission (if any) */
-  agentResults?: AuthorizationsResponse
-}

package/src/dex/hyperliquid.ts

@@ -1,20 +0,0 @@
-import type { DexAuthProvider } from './types.js'
-
-export const hyperliquidAuthProvider: DexAuthProvider = {
-  getAuthorizationInputs({ signingMode, agentAddress }) {
-    if (signingMode === 'USER') {
-      return {
-        user: [{ key: 'ApproveBuilderFee' }, { key: 'UserSetAbstraction' }],
-        agent: [],
-      }
-    }
-    // USER_AGENT
-    return {
-      user: [
-        { key: 'ApproveAgent', params: { agentAddress } },
-        { key: 'ApproveBuilderFee' },
-      ],
-      agent: [{ key: 'AgentSetAbstraction' }],
-    }
-  },
-}

package/src/dex/registry.ts

@@ -1,15 +0,0 @@
-import { PerpsSDKError } from '../errors/PerpsSDKError.js'
-import { hyperliquidAuthProvider } from './hyperliquid.js'
-import type { DexAuthProvider } from './types.js'
-
-const providers: Record<string, DexAuthProvider> = {
-  hyperliquid: hyperliquidAuthProvider,
-}
-
-export function getDexAuthProvider(dex: string): DexAuthProvider {
-  const provider = providers[dex]
-  if (!provider) {
-    throw new PerpsSDKError(new Error(`Unsupported dex: ${dex}`))
-  }
-  return provider
-}

package/src/dex/types.ts

@@ -1,16 +0,0 @@
-import type { Address, AuthorizationInput } from '@lifi/perps-types'
-import type { SigningMode } from '../client/types.js'
-
-export interface DexAuthInputs {
-  /** Authorizations requiring user wallet signature */
-  user: AuthorizationInput[]
-  /** Authorizations the agent auto-signs after user auths succeed */
-  agent: AuthorizationInput[]
-}
-
-export interface DexAuthProvider {
-  getAuthorizationInputs(params: {
-    signingMode: SigningMode
-    agentAddress?: Address
-  }): DexAuthInputs
-}

package/src/errors/AgentError.ts

@@ -1,43 +0,0 @@
-import { PerpsErrorCode } from '@lifi/perps-types'
-import { version } from '../version.js'
-import { PerpsErrorName } from './constants.js'
-import { PerpsError } from './PerpsError.js'
-
-/**
- * Error thrown when agent-related operations fail (agent not found, authorization issues, etc.)
- */
-export class AgentError extends PerpsError {
-  override name = PerpsErrorName.AgentError
-
-  constructor(message: string, code = PerpsErrorCode.AgentUnauthorized) {
-    super(code, message)
-    this.name = PerpsErrorName.AgentError
-
-    // Override message format
-    this.message = `[${PerpsErrorName.AgentError}] ${message}\nLI.FI Perps SDK version: ${version}`
-  }
-
-  /**
-   * Create an AgentError for a missing agent.
-   *
-   * @param address - The user address
-   * @param dex - The DEX identifier
-   */
-  static notFound(address: string, dex: string): AgentError {
-    return new AgentError(
-      `Agent not found for ${address} on ${dex}. Call setSigningMode() first.`
-    )
-  }
-
-  /**
-   * Create an AgentError for an unauthorized agent.
-   *
-   * @param address - The agent address
-   * @param dex - The DEX identifier
-   */
-  static unauthorized(address: string, dex: string): AgentError {
-    return new AgentError(
-      `Agent ${address} is not authorized on ${dex}. Submit authorization first.`
-    )
-  }
-}

package/src/errors/HTTPError.ts

@@ -1,72 +0,0 @@
-import type { PerpsErrorBody } from '@lifi/perps-types'
-import { PerpsErrorCode } from '@lifi/perps-types'
-import { PerpsErrorName } from './constants.js'
-import { PerpsError } from './PerpsError.js'
-
-const statusCodeToErrorCode = new Map<number, PerpsErrorCode>([
-  [400, PerpsErrorCode.ValidationError],
-  [401, PerpsErrorCode.SignatureInvalid],
-  [403, PerpsErrorCode.AgentUnauthorized],
-  [404, PerpsErrorCode.MarketNotFound],
-  [422, PerpsErrorCode.ValidationError],
-  [424, PerpsErrorCode.ThirdPartyError],
-  [429, PerpsErrorCode.ServerError],
-  [500, PerpsErrorCode.ServerError],
-  [502, PerpsErrorCode.ServerError],
-  [503, PerpsErrorCode.ServerError],
-  [504, PerpsErrorCode.TimeoutError],
-])
-
-function getErrorCodeFromStatus(status: number): PerpsErrorCode {
-  return statusCodeToErrorCode.get(status) ?? PerpsErrorCode.ServerError
-}
-
-function createInitialMessage(response: Response): string {
-  const statusCode =
-    response.status || response.status === 0 ? response.status : ''
-  const title = response.statusText || ''
-  const status = `${statusCode} ${title}`.trim()
-  const reason = status ? `status code ${status}` : 'an unknown error'
-  return `Request failed with ${reason}`
-}
-
-export class HTTPError extends PerpsError {
-  response: Response
-  status: number
-  url: string
-  responseBody?: PerpsErrorBody
-
-  constructor(response: Response, url: string) {
-    const code = getErrorCodeFromStatus(response.status)
-    const message = createInitialMessage(response)
-
-    super(code, message)
-
-    this.name = PerpsErrorName.HTTPError
-    this.response = response
-    this.status = response.status
-    this.url = url
-  }
-
-  async buildAdditionalDetails(): Promise<this> {
-    try {
-      this.responseBody = (await this.response.json()) as PerpsErrorBody
-
-      if (this.responseBody) {
-        // Update code from response body if available
-        if (this.responseBody.code) {
-          this.code = this.responseBody.code
-        }
-
-        // Append server message
-        if (this.responseBody.message) {
-          this.message = `${this.message}. ${this.responseBody.message}`
-        }
-      }
-    } catch {
-      // Response body parsing failed - use defaults
-    }
-
-    return this
-  }
-}